C# dynamic

dynamic dynamicVariable = 10;
dynamicVariable = "Now I am a string"; // Valid: Type is evaluated at runtime
dynamicVariable.NonExistentMethod();   // Compiles successfully; throws RuntimeBinderException at runtime

​

Core Mechanics

1. Underlying Type: At the IL level, dynamic is compiled as System.Object. The compiler applies the System.Runtime.CompilerServices.DynamicAttribute to the metadata to signal to the runtime that the member requires dynamic dispatch.
2. Dynamic Language Runtime (DLR): The compiler emits DLR “call site” payloads. A call site is a caching mechanism that records the runtime type of the object and the operation being performed.
3. Late Binding: The DLR inspects the object’s actual System.Type at runtime. If the requested member exists and the arguments match, the DLR executes the operation. If the binding fails, it throws a Microsoft.CSharp.RuntimeBinder.RuntimeBinderException.

​

dynamic vs. object vs. var

// var: Compile-time type inference. The compiler determines the exact type.
var implicitlyTyped = "String value";
// implicitlyTyped.Foo(); // COMPILER ERROR: string does not contain 'Foo'

// object: Compile-time type checking. The variable is strictly treated as System.Object.
object objectTyped = "String value";
// objectTyped.ToUpper(); // COMPILER ERROR: object does not contain 'ToUpper'

// dynamic: Runtime type resolution. The compiler ignores member validation.
dynamic dynamicallyTyped = "String value";
dynamicallyTyped.ToUpper(); // COMPILES. Executes successfully at runtime.

​

Implicit Conversions

dynamic d = 42;      // Implicit conversion from int to dynamic
int i = d;           // Implicit conversion from dynamic to int
string s = d;        // Compiles, but throws RuntimeBinderException at runtime (cannot implicitly convert int to string)

​

Technical Limitations

• Extension Methods: The DLR cannot resolve extension methods at runtime. Extension methods are a compile-time syntactic sugar that requires the compiler to search static classes in the current using directives.

dynamic list = new List<int> { 1, 2, 3 };
// list.FirstOrDefault(); // RuntimeBinderException
Enumerable.FirstOrDefault(list); // Valid: Explicit static method call

• Anonymous Functions: You cannot assign a lambda expression directly to a dynamic variable because lambdas do not have a strict type until they are cast to a specific delegate or expression tree.

// dynamic d = x => x + 1; // COMPILER ERROR
dynamic d = (Func<int, int>)(x => x + 1); // Valid

• Local Variable Type Inference: If a method returns dynamic, assigning its result to a variable declared with var results in the local variable also being typed as dynamic.