[C#] 동적 변수는 성능에 어떤 영향을 미칩니 까?

업데이트 : 사전 컴파일 및 지연 컴파일 된 벤치 마크 추가

업데이트 2 : 밝혀졌다, 내가 틀렸다. 완전하고 정확한 답변은 Eric Lippert의 게시물을 참조하십시오. 벤치 마크 수치를 위해 여기에 남겨 두겠습니다.

* 업데이트 3 : Mark Gravell의이 질문에 대한 답변을 기반으로 IL-Emitted 및 Lazy IL-Emitted 벤치 마크가 추가되었습니다 .

내가 아는 한 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 메서드를 7 가지 방법으로 호출하려고합니다.

1. 직접 메서드 호출
2. 사용 dynamic
3. 반사로
4. Action런타임에 미리 컴파일 된를 사용 합니다 (따라서 결과에서 컴파일 시간 제외).
5. 사용 Action(따라서, 컴파일 시간 포함)이 아닌 스레드 안전 레이지 변수를 사용하여, 필요 처음 컴파일을 가도록
6. 테스트 전에 생성되는 동적 생성 방법을 사용합니다.
7. 테스트 중에 느리게 인스턴스화되는 동적 생성 메서드를 사용합니다.

각각은 간단한 루프에서 백만 번 호출됩니다. 타이밍 결과는 다음과 같습니다.

직접 : 3.4248ms
동적 : 45.0728ms
반사 : 888.4011ms
사전 컴파일 : 21.9166ms
LazyCompiled : 30.2045ms
ILEmitted : 8.4918ms
LazyILEmitted : 14.3483ms

따라서 dynamic키워드 를 사용하는 것은 메서드를 직접 호출하는 것보다 훨씬 더 오래 걸리지 만, 여전히 약 50 밀리 초 내에 작업을 백만 번 완료 할 수 있으므로 리플렉션보다 훨씬 빠릅니다. 우리가 호출하는 메서드가 몇 개의 문자열을 함께 결합하거나 값을 찾기 위해 컬렉션을 검색하는 것과 같이 집약적 인 작업을 수행하려는 경우 이러한 작업이 직접 호출과 호출 간의 차이보다 훨씬 더 큽니다 dynamic.

성능은 dynamic불필요하게 사용 하지 않는 여러 가지 좋은 이유 중 하나 일 뿐이지 만 진정한 dynamic데이터를 처리 할 때 단점보다 훨씬 더 큰 장점을 제공 할 수 있습니다.

업데이트 4

Johnbot의 의견에 따라 Reflection 영역을 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();
    }),

… 다음은 벤치 마크 결과입니다.

따라서 많이 호출해야하는 특정 메서드를 미리 결정할 수있는 경우 해당 메서드를 참조하는 캐시 된 대리자를 호출하는 것은 메서드 자체를 호출하는 것만 큼 빠릅니다. 그러나 호출 할 때 호출 할 메서드를 결정해야하는 경우 대리자를 만드는 데 비용이 많이 듭니다.

답변