Jak zmienna dynamiczna wpływa na wydajność?

aktualizacja: Dodano prekompilowane i Lazy-skompilowane benchmarki

Update 2: okazuje się, że się mylę. Zobacz post Erica Lipperta, aby uzyskać pełną i poprawną odpowiedź. Zostawiam to tutaj ze względu na liczby odniesienia

*Update 3: dodano benchmarki IL-emitowane i Lazy IL-emitowane, oparte na odpowiedzi Marka Gravella na to pytanie .

z mojej wiedzy użycie słowa kluczowego dynamic nie powoduje żadnej dodatkowej kompilacji w czasie wykonywania w i samego siebie (chociaż wyobrażam sobie, że może to zrobić w konkretnych okolicznościach, w zależności od tego, jakiego typu obiekty wspierają twoje zmienne dynamiczne).

Jeśli chodzi o wydajność, dynamic z natury wprowadza pewne koszty, ale nie tak bardzo, jak mogłoby się wydawać. Na przykład po prostu uruchomiłem benchmark, który wygląda tak:

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

Jak widać z kodu, próbuję wywołać prostą metodę no-op na siedem różnych sposobów:

1. metoda bezpośrednia call
2. używając dynamic
3. przez odbicie
4. używając Action, który został wstępnie skompilowany w czasie wykonywania(wykluczając tym samym czas kompilacji z wyników).
Nie jest to jednak możliwe, ponieważ nie jest to możliwe, ponieważ nie jest to możliwe, ponieważ nie jest to możliwe.]}
5. przy użyciu dynamicznie generowanej metody, która zostanie utworzona przed testem.
6. Za pomocą dynamicznie generowanej metody, która leniwie tworzy instancję podczas test.

Każdy zostanie wywołany milion razy w prostej pętli. Oto wyniki czasowe:

Direct: 3.4248 ms
Dynamiczny: 45.0728 ms
Reflection: 888.4011 ms
Precompiled: 21.9166 ms
LazyCompiled: 30.2045 ms
ILEmitted: 8.4918 ms
Lazyilemited: 14.3483 ms

Tak więc użycie słowa kluczowego dynamic trwa o rząd wielkości dłużej niż bezpośrednie wywołanie metody, nadal udaje mu się zakończyć operację a milion razy w około 50 milisekund, co czyni go znacznie szybszym niż odbicie. Jeśli wywołana przez nas metoda próbuje zrobić coś intensywnego, jak połączenie kilku łańcuchów lub przeszukiwanie kolekcji dla wartości, operacje te prawdopodobnie znacznie przewyższają różnicę między wywołaniem bezpośrednim a wywołaniem dynamic.

Update 4

Bazując na komentarzu Johnbota, podzieliłem obszar refleksji na cztery oddzielne testy:

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

... a oto wyniki benchmarka:

Więc jeśli możesz z góry określić konkretną metodę, którą będziesz musiał często wywoływać, wywołanie buforowanego delegata odnoszącego się do tej metody jest mniej więcej tak szybkie, jak wywołanie samej metody. Jeśli jednak musisz określić, którą metodę wywołać, gdy masz zamiar wywołaj go, tworzenie delegata dla niego jest bardzo kosztowne.