Object vs Dynamic vs Var and ExpandoObject

The Object type has existed since the beginning of C#, in other words C# 1.0 and exists at System.Object. Var comes next in C# 3.0 followed by the dynamic keyword in C# 4.0.

Object

Now object comes from C# 1.0 and derives from System.Object and we can assign any value to this reference.

    static void Main(string[] args)
    {
        object iobj = 10; //Perfectly Legal
        var ivar = 10;
        dynamic dvar = 10;
        Console.WriteLine(iobj.GetType());// gives System.int32.
        Console.WriteLine(ivar.GetType());// gives System.int32.
        Console.WriteLine(dvar.GetType());// gives System.int32.
        // Reason-This is  because int is the type  value stored IN ALL REFRENCE TYPE.
      1)
      iobj = iobj + 10; //Illegal and gives compile time error.
        //Reason- at compile time its is object type,so compiler doesnt have any idea how to add object              type,for this you need to cast in integer.
        //Looking at IL for this:
        // .locals init ([0] object iobj)
        //In order to add ,you need explicit cast
        iobj = (int)iobj + 10;
        Console.WriteLine(iobj); //Perfectly legal
        2)
        ivar = ivar + 10; //Perfectly legal
        //Reason-At compile time,it is not var type but int type,let us see IL
        //.locals init ([1] int32 ivar,
        Console.ReadLine();

        3)
        dvar = dvar + 10; //Perfectly legal
      //Reason-At compile time,it is not var type but int type,let us see IL
         Console.ReadLine();
}

So what's the difference between var and dynamic?

 

1. var was introduced in C# 3.0. Dynamic was introduced in C# 4.0.
   
   
2. var is statically typed, in other words the data type of var is inferred at compile time. Dynamic is a dynamic type and the value type is inferred at runtime.
   
   
3. Vars are initialized during declaration. A dynamic can be initialized at runtime.
   
   
4. Var cannot be used to create a return type of a function or property. Dynamic can be used as the return type or properties.
   
   
5. var cannot change the data type. A dynamic can change its data type later.
   

   //var val = 10;
   //val = "string";//Illegal as now it need to cast in into string
   dynamic dynam = 10;
   dynam = "string1"; //Perfectly Legal
   Console.ReadLine();

"As part of the process, variables of type dynamic are compiled into variables of type object. Therefore, type dynamic exists only at compile time, not at run time." -MSDN

The following are the usage of these two.

• They are used to reduce the number of lines of code. We do not need to write the type name again and again.
  

  Dictionary<string, Control> d = new Dictionary<string, Control>();

  That can now be written simply as:
  

  var d = new Dictionary<string, Control>();
  
  dynamic d = new Dictionary<string, Control>();

• They are used extensively in anonymous methods. You wouldn't be able to declare a variable of an anonymous type if you always need to include the type name as part of the variable declaration.
  
• COM interop.
  
• Reading XML, JSON without creating custom classes.

Difference between object and dynamic

Dynamic tells the compiler that the data type can be anything so the compiler doesn't interfere and hence dynamic gives no compile-time error but will definitely give a runtime error is all is not good (in other words runtime error).

The following code will work properly for dynamic but not if dynamic is replaced by object. (The reason is explained in the preceding in the object type discussion.)

dyn = 10.0;
dyn = dyn + 10;

dyn = "10";
dyn = dyn + 10;

So if dynamic can take any data type, can we pass it to another function expecting something other data type and crash?

Assume we have a function:

public static void display(string abc)
{
    Console.WriteLine(abc);
}

Now we have:

object iobj = 10;
      display(iobj);

      dynamic dynam = 10;
      display(dynam);
      Console.ReadLine();

Here, the first one will not compile and the second one will compile but give a runtime error.

Dynamic suppresses the compiler logic.

With the dynamic keyword, one interesting object comes out to be ExpandoObject.

In order to emulate the dynamic functionality of adding members to objects at runtime, .Net comes with the IDynamicMetaObjectProvider interface. Classes implementing it will have a full dynamic behavior.

A useful class in version 4 of the .NET Framework is ExpandoObject. It is a built-in implementation of the IDynamicMetaObjectProvider interface and it allows dynamically adding members at runtime, like in the following example:

dynamic contact = new ExpandoObject();
contact.Name = "GOGO";
contact.Phone = "206-555-0144";
contact.Address = new ExpandoObject(); //Notice this line
contact.Address.Street = "Main St";

The code is taken from MSDN. This has the following two interesting features.

1. Here, we have not used ExpandoObject=new ExpandoObject () because doing so will make it a statically-typed object of the ExpandoObject type. And of course, statically-typed variables cannot add members at run time.
   
   
2. To add another node to the contact node, simply add another ExpandoObject. (In other words contact.Address = newExpandoObject()).