What is dynamic in C#? How does the DLR bind calls at run time, how does it differ from object and var, and when is it a reasonable choice?

1. What the compiler emits

dynamic d = GetSomething();
int n = d.Count + 1;

becomes, roughly:

static CallSite<Func<CallSite, object, object>> s_getCount;
static CallSite<Func<CallSite, object, int, object>> s_add;
static CallSite<Func<CallSite, object, int>> s_convert;

s_getCount ??= CallSite<...>.Create(Binder.GetMember(CSharpBinderFlags.None, "Count", typeof(Program), ...));
s_add      ??= CallSite<...>.Create(Binder.BinaryOperation(..., ExpressionType.Add, ...));
s_convert  ??= CallSite<...>.Create(Binder.Convert(..., typeof(int), ...));

object count = s_getCount.Target(s_getCount, d);
object sum   = s_add.Target(s_add, count, 1);
int n        = s_convert.Target(s_convert, sum);

Every dynamic operation — member access, invocation, operator, conversion, indexer — is a separate call site. The dynamic type itself is just object marked with [Dynamic] in metadata.

2. The three-level cache

• L0: the call site's Target delegate, rewritten to the most recently successful rule; if its type test passes, it executes immediately.
• L1: a small per-call-site list of recently used rules (handles a few runtime types at one call site, e.g. polymorphic objects).
• L2: a binder-level cache shared across call sites with the same binder.
• Miss: the binder runs C# semantic analysis against the runtime types, builds an expression tree with a restriction (type test), compiles it, and updates the caches.

Polymorphic call sites that see many different types degrade, because the cache keeps missing and recompiling — which is why dynamic in a loop over heterogeneous objects can be very slow.

3. The C# runtime binder replicates the compiler

Microsoft.CSharp.dll contains a slimmed-down version of C# semantic analysis so dynamic calls behave like static C#: overload resolution, implicit conversions, operator lookup, accessibility (based on the calling context type passed to the binder). This is why:

• Private members are accessible if the dynamic call is made from inside the declaring class.
• Extension methods are not available on dynamic — the binder does not know which using directives were in scope. d.Where(...) fails at run time; call Enumerable.Where(d, ...) instead.
• Lambdas cannot be passed directly as arguments to dynamic calls (the binder cannot infer a delegate type); cast them first.
• Anonymous types accessed via dynamic from another assembly fail, because anonymous types are internal.

4. IDynamicMetaObjectProvider, ExpandoObject and DynamicObject

Objects implementing IDynamicMetaObjectProvider supply a DynamicMetaObject that tells the DLR how to bind operations on them:

• ExpandoObject stores members in an internal dictionary and implements IDictionary<string, object?> and INotifyPropertyChanged. expando.Name = "Ada" adds a key.
• DynamicObject is a base class with overridable TryGetMember, TrySetMember, TryInvokeMember — handy for wrappers over dictionaries, configuration or REST resources.

5. Performance numbers (order of magnitude)

First-call cost matters for cold starts (Azure Functions, serverless) and for code paths executed once per request with many call sites.

6. Trimming and NativeAOT

The C# runtime binder needs reflection over arbitrary types and System.Linq.Expressions compilation. Trimming can remove the members you call dynamically (they have no static references), and NativeAOT cannot JIT-compile expression trees (they fall back to an interpreter, if they work at all). The SDK emits trim warnings (IL2026) for dynamic usage. ASP.NET Core and System.Text.Json steer toward source-generated, statically typed code for this reason.

7. Modern alternatives

Try it yourself

1. Decompile a method using dynamic in ILSpy (with "decompile dynamic" turned off) and inspect the call sites.
2. Benchmark static, reflection and dynamic property access with BenchmarkDotNet, including a first-call measurement.
3. Try calling a LINQ extension method on a dynamic list and read the RuntimeBinderException.
4. Publish a small console app using dynamic with <PublishAot>true</PublishAot> and read the warnings.

using System.Dynamic;
using System.Text.Json;
using System.Text.Json.Nodes;
using Microsoft.CSharp.RuntimeBinder;

namespace Types;

public sealed record PartnerOrder(string OrderId, decimal Total);

public static class DynamicDemo
{
    public static void Main()
    {
        // var: static inference
        var text = "hello";
        Console.WriteLine(text.Length);

        // object: static, needs a cast
        object boxed = "hello";
        Console.WriteLine(((string)boxed).Length);

        // dynamic: bound at run time
        dynamic d = "hello";
        Console.WriteLine(d.Length);          // works
        try
        {
            Console.WriteLine(d.Lenght);      // typo compiles, fails at run time
        }
        catch (RuntimeBinderException ex)
        {
            Console.WriteLine($"Binder: {ex.Message}");
        }

        // ExpandoObject: a legitimate dynamic use (property bag)
        dynamic bag = new ExpandoObject();
        bag.Name = "Ada";
        bag.Score = 42;
        foreach (var (key, value) in (IDictionary<string, object?>)bag)
            Console.WriteLine($"{key} = {value}");

        // Preferred for JSON: typed records, or JsonNode for unknown shapes
        const string json = """{ "orderId": "A-1", "total": 99.50 }""";
        var options = new JsonSerializerOptions(JsonSerializerDefaults.Web);
        PartnerOrder? order = JsonSerializer.Deserialize<PartnerOrder>(json, options);
        Console.WriteLine(order);

        JsonNode? node = JsonNode.Parse(json);
        decimal? total = node?["total"]?.GetValue<decimal>();
        Console.WriteLine(total);
    }
}