¿Cómo afecta tener una variable dinámica al rendimiento?

Actualización: Se agregaron puntos de referencia precompilados y compilados perezosamente

Actualización 2: Resulta que estoy equivocado. Vea el post de Eric Lippert para una respuesta completa y correcta. Dejo esto aquí por el bien de los números de referencia

*Actualización 3: Se agregaron puntos de referencia de emisión de IL y emisión de IL Perezosa, basados en La respuesta de Mark Gravell a esta pregunta.

Que yo sepa, el uso de la palabra clave dynamic no causa ninguna compilación adicional en tiempo de ejecución en y de sí mismo (aunque me imagino que podría hacerlo bajo circunstancias específicas, dependiendo de qué tipo de objetos respaldan sus variables dinámicas).

En cuanto al rendimiento, dynamic introduce inherentemente algunos gastos generales, pero no tanto como se podría pensar. Por ejemplo, acabo de ejecutar un benchmark que se ve así:

void Main()
{
    Foo foo = new Foo();
    var args = new object[0];
    var method = typeof(Foo).GetMethod("DoSomething");
    dynamic dfoo = foo;
    var precompiled = 
        Expression.Lambda<Action>(
            Expression.Call(Expression.Constant(foo), method))
        .Compile();
    var lazyCompiled = new Lazy<Action>(() =>
        Expression.Lambda<Action>(
            Expression.Call(Expression.Constant(foo), method))
        .Compile(), false);
    var wrapped = Wrap(method);
    var lazyWrapped = new Lazy<Func<object, object[], object>>(() => Wrap(method), false);
    var actions = new[]
    {
        new TimedAction("Direct", () => 
        {
            foo.DoSomething();
        }),
        new TimedAction("Dynamic", () => 
        {
            dfoo.DoSomething();
        }),
        new TimedAction("Reflection", () => 
        {
            method.Invoke(foo, args);
        }),
        new TimedAction("Precompiled", () => 
        {
            precompiled();
        }),
        new TimedAction("LazyCompiled", () => 
        {
            lazyCompiled.Value();
        }),
        new TimedAction("ILEmitted", () => 
        {
            wrapped(foo, null);
        }),
        new TimedAction("LazyILEmitted", () => 
        {
            lazyWrapped.Value(foo, null);
        }),
    };
    TimeActions(1000000, actions);
}

class Foo{
    public void DoSomething(){}
}

static Func<object, object[], object> Wrap(MethodInfo method)
{
    var dm = new DynamicMethod(method.Name, typeof(object), new Type[] {
        typeof(object), typeof(object[])
    }, method.DeclaringType, true);
    var il = dm.GetILGenerator();

    if (!method.IsStatic)
    {
        il.Emit(OpCodes.Ldarg_0);
        il.Emit(OpCodes.Unbox_Any, method.DeclaringType);
    }
    var parameters = method.GetParameters();
    for (int i = 0; i < parameters.Length; i++)
    {
        il.Emit(OpCodes.Ldarg_1);
        il.Emit(OpCodes.Ldc_I4, i);
        il.Emit(OpCodes.Ldelem_Ref);
        il.Emit(OpCodes.Unbox_Any, parameters[i].ParameterType);
    }
    il.EmitCall(method.IsStatic || method.DeclaringType.IsValueType ?
        OpCodes.Call : OpCodes.Callvirt, method, null);
    if (method.ReturnType == null || method.ReturnType == typeof(void))
    {
        il.Emit(OpCodes.Ldnull);
    }
    else if (method.ReturnType.IsValueType)
    {
        il.Emit(OpCodes.Box, method.ReturnType);
    }
    il.Emit(OpCodes.Ret);
    return (Func<object, object[], object>)dm.CreateDelegate(typeof(Func<object, object[], object>));
}

Como se puede ver en el código, trato de invocar un método simple no-op de siete maneras diferentes:

1. método Directo call
2. Usando dynamic
3. Por reflexión
4. Usando un Action precompilado en tiempo de ejecución (excluyendo así el tiempo de compilación de los resultados).
5. Usando un Action que se compila la primera vez que se necesita, usando una variable perezosa no segura para subprocesos (por lo tanto, incluyendo el tiempo de compilación)
6. Usando un método generado dinámicamente que se crea antes de la prueba.
7. Utilizando un método generado dinámicamente que se instancian perezosamente durante el prueba.

Cada uno es llamado 1 millón de veces en un bucle simple. Aquí están los resultados del tiempo:

Directo: 3.4248 ms
Dinámica: 45.0728 ms
Reflexión: 888.4011 ms
Precompilado: 21.9166 ms
LazyCompiled: 30.2045 ms
Presentado: 8.4918 ms
LazyILEmitted: 14.3483 ms

Así que mientras que el uso de la palabra clave dynamic toma un orden de magnitud más largo que llamar al método directamente, todavía se las arregla para completar la operación a millones de veces en unos 50 milisegundos, por lo que es mucho más rápido que el reflejo. Si el método que llamamos estuviera tratando de hacer algo intensivo, como combinar unas pocas cadenas juntas o buscar un valor en una colección, esas operaciones probablemente superarían con creces la diferencia entre una llamada directa y una llamada dynamic.

El rendimiento es solo una de las muchas buenas razones para no usar dynamic innecesariamente, pero cuando se trata de datos verdaderamente dynamic, puede proporcionar ventajas que superan con creces la desventaja.

Actualización 4

Basado en el comentario de Johnbot, dividí el área de Reflexión en cuatro pruebas separadas: {[14]]}

    new TimedAction("Reflection, find method", () => 
    {
        typeof(Foo).GetMethod("DoSomething").Invoke(foo, args);
    }),
    new TimedAction("Reflection, predetermined method", () => 
    {
        method.Invoke(foo, args);
    }),
    new TimedAction("Reflection, create a delegate", () => 
    {
        ((Action)method.CreateDelegate(typeof(Action), foo)).Invoke();
    }),
    new TimedAction("Reflection, cached delegate", () => 
    {
        methodDelegate.Invoke();
    }),

... y aquí están los resultados de referencia:

Así que si puedes predeterminar un método específico al que necesitarás llamar mucho, invocar un delegado en caché que se refiera a ese método es tan rápido como llamar al método en sí. Sin embargo, si necesita determinar a qué método llamar justo cuando está a punto de hacerlo invocarlo, crear un delegado para ello es muy caro.