Difference Between Var, Dynamic And Object type In C#

Declaration of a dynamic type is allowed without initialization because its type is determined at runtime. Please see the following snippet, which displays an IntelliSense not available for dynamic type.

Dynamic types can be passed method parameters.

static void Main(string[] args) {
    dynamic salary;
    salary = 10;
    Console.WriteLine(salary);
    GetData(salary);
}
private static void GetData(dynamic salary) {
    Type type = salary.GetType();
    string typeName = type.Name;
    if (typeName == "Int32") {
        int salaryInInt = Convert.ToInt32(salary);
    } else {
        Console.WriteLine("It is not an Integer");
    }
}

Let's discuss the "object" keyword.

1. The object was introduced in C# 1.
2. It can store any type of value because it is the base class for all types in C#.
3. You need to typecast an object value to a specific type before you perform any manipulation on it.
4. You need to be very careful while using objects because it will create problems at runtime if it is not able to convert to a specific type while being typecast.

The object can store any type of value. Please see the code snippet below.

static void Main(string[] args) {
    object x = 10;
    object y = "C# corner";
    object z = 100.10;
    object total = Convert.ToDecimal(x) + Convert.ToDecimal(z);
}

You need to typecast an object value to a specific type before you perform any manipulation on it. Check out the example below to see what I mean.

private static void GetData(object salary) {
    Type type = salary.GetType(); //Here GetType() to get type of of object
    string typeName = type.Name;
    if (typeName == "Int32") // Check for specific type, Here checked for int type
    {
        // This code will execute only if parameter value is type of integer else will return this values is not an integer
        int addPercentageToSalary = Convert.ToInt32(salary) + (Convert.ToInt32(salary) * 10 / 100);
    } else {
        Console.WriteLine("It is not an Integer");
    }
}

Now let's check the difference among all three

1. Introduced in which version?
   • Object type were introduced in C# 1.0.
   • Var keyword was introduced in C# 3.0.
   • Dynamic type introduced in C# 4.0.
2. declaration and initialization
   • Object: Initialization is not required at the time of declaration.
   • Var: Initialization is mandatory.
   • Dynamic: Initialization is not mandatory.
3. Value storage
   • Object: Because object is the base class for all types, it can store any type of value.
   • Var: It can store any type of value, but initialization is mandatory, so once you initialise with one type, the type cannot change.
   • dynamic: can store any type of value; we can also change the type in the following use.
4. Is casting required?
   • Object: Before performing any operation on an object, it must be cast to its original type.
   • Var: casting does not require it because we have type information at compile time and intellisense, which will assist us in determining the type of variable.
   • Dynamic: need to cast to orignal type before performing any operation on it.
5. can be passed as a method argument?
   • Object: Yes, we can pass it as a method argument.
   • Var: No.
   • dynamic, just like an object, we can pass dynamic as a method parameter.
6. Will it support Intellisense?
   • Object: No
   • Var: Yes, It supports intellisense because it is known at compile time.
   • Dynamic: No, compilers do not have information at compile time.

Summary

In this article, we learned about three types: var, dynamic, and object. As explained in the article, each of the three has its own set of applications. I hope this will help you.

Thanks for reading.