动态变量如何影响性能？

关于性能，dynamic 确实会引入一些开销，但并没有您想象的那么多。例如，我刚刚运行了一个如下所示的基准测试：

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>));
}

从代码中可以看出，我尝试以七种不同的方式调用一个简单的无操作方法：

直接方法调用使用动态通过反射使用在运行时预编译的操作（因此从结果中排除编译时间）。使用第一次需要编译的动作，使用非线程安全的惰性变量（因此包括编译时间）使用在测试之前创建的动态生成的方法。使用在测试期间延迟实例化的动态生成的方法。

每个都在一个简单的循环中被调用 100 万次。以下是计时结果：

直接：3.4248ms 动态：45.0728ms 反射：888.4011ms 预编译：21.9166ms LazyCompiled：30.2045ms ILEmitted：8.4918ms LazyILEmitted：14.3483ms

因此，虽然使用 dynamic 关键字比直接调用该方法花费的时间要长一个数量级，但它仍然设法在大约 50 毫秒内完成一百万次操作，远远快于反射。如果我们调用的方法试图做一些密集的事情，比如将几个字符串组合在一起或在集合中搜索一个值，那么这些操作可能会远远超过直接调用和 dynamic 调用之间的差异。

性能只是不必要地使用 dynamic 的众多充分理由之一，但是当您处理真正的 dynamic 数据时，它可以提供远远超过缺点的优点。

更新 4

根据 Johnbot 的评论，我将反射区域分为四个单独的测试：

    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();
    }),

...这是基准测试结果：

https://i.stack.imgur.com/ufSE0.png

因此，如果您可以预先确定需要大量调用的特定方法，则调用引用该方法的缓存委托与调用方法本身的速度差不多。但是，如果您需要在即将调用它时确定要调用哪个方法，那么为它创建一个委托是非常昂贵的。