What is the difference between dynamic type variables and object type variables?

In C#, both dynamic and object type variables can store values of any type, but they differ significantly in how type checking is performed. Understanding this difference is crucial for writing efficient and safe C# code.

The object type is the ultimate base class for all data types in C# Common Type System (CTS). It serves as an alias for System.Object class. All types in C# inherit from object, making it possible to assign any value to an object variable.

The dynamic type bypasses compile-time type checking entirely. Operations on dynamic variables are resolved at runtime using the Dynamic Language Runtime (DLR), providing more flexibility but with potential runtime errors.

Syntax

Following is the syntax for declaring object and dynamic variables −

object objVariable = value;
dynamic dynVariable = value;

Key Differences

Using Object Type Variables

Object type variables require explicit casting to access type-specific members −

using System;

class Program {
   public static void Main() {
      object obj1 = 100;
      object obj2 = "Hello World";
      object obj3 = 45.5;
      
      Console.WriteLine("obj1: " + obj1);
      Console.WriteLine("obj2: " + obj2);
      Console.WriteLine("obj3: " + obj3);
      
      // Explicit casting required
      int number = (int)obj1;
      string text = (string)obj2;
      Console.WriteLine("Casted values: " + number + ", " + text);
   }
}

The output of the above code is −

obj1: 100
obj2: Hello World
obj3: 45.5
Casted values: 100, Hello World

Using Dynamic Type Variables

Dynamic type variables can be used without explicit casting, but errors occur at runtime −

using System;

class Program {
   public static void Main() {
      dynamic dyn1 = 100;
      dynamic dyn2 = "Hello World";
      dynamic dyn3 = 45.5;
      
      Console.WriteLine("dyn1: " + dyn1);
      Console.WriteLine("dyn2: " + dyn2);
      Console.WriteLine("dyn3: " + dyn3);
      
      // No explicit casting needed
      int result = dyn1 + 50;
      string upper = dyn2.ToUpper();
      Console.WriteLine("Dynamic operations: " + result + ", " + upper);
      
      // Type can change at runtime
      dyn1 = "Now I'm a string";
      Console.WriteLine("dyn1 changed: " + dyn1);
   }
}

The output of the above code is −

dyn1: 100
dyn2: Hello World
dyn3: 45.5
Dynamic operations: 150, HELLO WORLD
dyn1 changed: Now I'm a string

Runtime vs Compile-time Error Handling

using System;

class Program {
   public static void Main() {
      object obj = "Hello";
      dynamic dyn = "World";
      
      // Object requires casting - compile-time safety
      try {
         string objStr = (string)obj;
         Console.WriteLine("Object cast successful: " + objStr);
      } catch (InvalidCastException e) {
         Console.WriteLine("Object cast failed: " + e.Message);
      }
      
      // Dynamic resolves at runtime
      try {
         string dynStr = dyn.ToUpper();
         Console.WriteLine("Dynamic operation successful: " + dynStr);
         
         // This will cause runtime error if uncommented
         // int dynInt = dyn + 10;
      } catch (Exception e) {
         Console.WriteLine("Dynamic operation failed: " + e.Message);
      }
   }
}

The output of the above code is −

Object cast successful: Hello
Dynamic operation successful: WORLD

When to Use Each Type

Use object type when:

• You need compile-time type safety

• Performance is critical

• Working with collections of mixed types

Use dynamic type when:

• Interoperating with COM objects or dynamic languages

• Working with reflection-heavy scenarios

• Type is genuinely unknown until runtime

Conclusion

The main difference between dynamic and object types lies in when type checking occurs: object types are checked at compile-time requiring explicit casting, while dynamic types are resolved at runtime with more flexibility but potential runtime errors. Choose object for type safety and performance, dynamic for flexibility and interoperability scenarios.