Как наличие динамической переменной влияет на производительность?

обновление: добавлены предварительно скомпилированные и лениво скомпилированные тесты

обновление 2: Оказывается, я ошибаюсь. Эрик Липперт для полного и правильного ответа. Я оставляю это здесь ради контрольных цифр

*обновление 3: добавлены Il-излучаемые и ленивые Il-излучаемые тесты, основанные на ответ Марка Гравелла на этот вопрос.

насколько мне известно, использование dynamic ключевое слово тут не вызывает никакой дополнительной компиляции во время выполнения само по себе (хотя я предполагаю, что это может сделать при определенных обстоятельствах, в зависимости от того, какие типы объектов поддерживают ваши динамические переменные).

что касается производительности, 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>));
}

как вы можете видеть из кода, я пытаюсь вызвать простой метод no-op seven разные способы:

1. прямой вызов метода
2. используя dynamic
3. рефлексия
4. С помощью Action который был предварительно скомпилирован во время выполнения (таким образом, исключая время компиляции из результатов).
5. С помощью Action который компилируется в первый раз, когда это необходимо, используя не потокобезопасную ленивую переменную (таким образом, включая время компиляции)
6. использование динамически сгенерированного метода, который создается до тест.
7. использование динамически генерируемого метода, который лениво создается во время теста.

каждый вызывается 1 миллион раз в простом цикле. Вот результаты:

прямой: 3,4248 МС
Динамика: 45.0728 МС
Отражение: 888.4011 МС
Предварительно скомпилированный: 21.9166 МС
LazyCompiled: 30.2045 ms
ILEmitted: 8.4918 ms
LazyILEmitted: 14.3483 ms

так при использовании dynamic ключевое слово занимает на порядок больше времени, чем вызов метода напрямую, он по-прежнему удается завершить операцию миллион раз в 50 миллисекунд, что гораздо быстрее, чем отражения. Если метод, который мы вызываем, пытается сделать что-то интенсивное, например, объединить несколько строк вместе или найти коллекцию для значения, эти операции, вероятно, намного перевесят разницу между прямым вызовом и dynamic звонок.

производительность просто одна из многих веских причин не использовать dynamic излишне, но когда вы имеете дело с истинно dynamic данные, он может обеспечить преимущества, которые перевешивают недостатки.

обновление 4

основываясь на комментарии Джонбота, я разбил область отражения на четыре отдельных теста:

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

... и вот результаты тестов:

так что если вы можете предопределить конкретный метод, который вам нужно будет вызвать много, вызов кэшированного делегата, ссылающегося на этот метод, примерно так же быстро, как вызов самого метода. Однако, если вам нужно определить, какой метод вызывать так же, как вы собираетесь вызвать его, создание делегата для него очень дорого.