使用表達式的C＃加速方法調用泛型類

Question

我需要調用泛型類的實例方法。簽名看起來像這樣：

public class HandlerFactory 
{ 
    public static IHandler<T> Create<T>(); 
} 

public interface IHandler<T> 
{ 
    T Read(Stream s); 

    void Write(Stream s, T v); 
} 

我設法通過使用表達式和DynamicInvoke得到它的工作。可悲的是DynamicInvoke的表現並不好。我不能將代理強制轉換爲Action<MemoryStream, T>，因爲我不知道編譯時的類型。

public class Test 
{ 
    public static void Write(MemoryStream s, object value) 
    { 
     var del = GetWriteDelegateForType(value.GetType()); 

     // TODO: How to make this faster? 
     del.DynamicInvoke(s, value); 
    } 

    private static object GetHandlerForType(Type type) 
    { 
     var expr = Expression.Call(typeof(HandlerFactory), "Create", new[] { type }); 
     var createInstanceLambda = Expression.Lambda<Func<object>>(expr).Compile(); 
     return createInstanceLambda(); 
    } 

    private static Delegate GetWriteDelegateForType(Type type) 
    { 
     var handlerObj = GetHandlerForType(type); 
     var methodInfo = handlerObj.GetType().GetMethod("Write", new[] { typeof(MemoryStream), type }); 

     var arg1 = Expression.Parameter(typeof(MemoryStream), "s"); 
     var arg2 = Expression.Parameter(type, "v"); 

     var handlerObjConstant = Expression.Constant(handlerObj); 
     var methodCall = Expression.Call(handlerObjConstant, methodInfo, arg1, arg2); 

     var lambda = Expression.Lambda(methodCall, arg1, arg2); 

     return lambda.Compile(); 
    } 
} 

請注意，我沒有基準lambda代，只是調用DynamicInvoke。

有什麼方法可以用更快的東西來代替DynamicInvoke嗎？

更新：我評估了3個答案，其中包含代碼示例，並選擇與Lasse V. Karlsen答案一起歸因於簡單性。 （上Grax的代碼注：儘管緩存MakeGenericMethod調用它似乎比在委託包裝調用方法要慢）

   Method |  Median |  StdDev | 
------------------- |-------------- |----------- | 
      MyLambda | 1,133.2459 ns | 25.1972 ns | 
     ExplicitCall |  0.6450 ns | 0.0256 ns | 
Test2DelegateLasse | 10.6032 ns | 0.2141 ns | 
     LambdaGroo | 10.7274 ns | 0.1099 ns | 
     InvokeGrax | 349.9428 ns | 14.6841 ns | 

Answer 1

要做到這一點的方法是通過適當的泛型方法，包裝從object加強到T，並跳過整個動態調用。

從引擎收錄你的代碼，這裏是你的測試類的新版本：

public class Test2 
{ 
    private static readonly Action<MemoryStream, object> del; 

    static Test2() 
    { 
     var genericCreateMethod = typeof(Test2).GetMethod("CreateWriteDelegate", BindingFlags.Static | BindingFlags.NonPublic); 
     var specificCreateMethod = genericCreateMethod.MakeGenericMethod(typeof(Model)); 
     del = (Action<MemoryStream, object>)specificCreateMethod.Invoke(null, null); 
    } 

    public static void Write(MemoryStream s, object value) 
    { 
     del(s, value); 
    } 

    private static Action<MemoryStream, object> CreateWriteDelegate<T>() 
    { 
     var handler = HandlerFactory.Create<T>(); 
     return delegate (MemoryStream s, object value) 
     { 
      handler.Write(s, (T)value); 
     }; 
    } 
} 

在我的機器代碼，上述以及執行爲：

您的測試： 1285ms
我的測試：20ms的
明確：4ms的

Answer 2

你可以只讓一個Action<MemoryStream, object>和簡單地使用Expression.Convert()改變v型從object到type。

爲了提高性能，您可以將這些Action s存儲在某些Type -keyed字典（併發？）中，但表達式需要對Create內部的處理程序進行一些更改。

Answer 3

編寫一個通用方法，並使用帶有Invoke的MakeGenericMethod來調用它。

將您想調用的方法存儲在一個靜態變量中，這樣GetMethod調用只需要發生一次。

然後在該MethodInfo上調用MakeGenericMethod並調用結果。

private static MethodInfo GenericWriteMethod = 
    typeof(Test).GetMethod("GenericWrite", BindingFlags.NonPublic | BindingFlags.Static); 

public static void Write(MemoryStream s, object value) 
{ 
    GenericWriteMethod 
     .MakeGenericMethod(value.GetType()) 
     .Invoke(null, new object[] { s, value }); 
} 

private static void GenericWrite<T>(MemoryStream s, T value) 
{ 
    HandlerFactory.Create<T>().Write(s, value); 
} 

在我的測試中，這使它快了100多倍。

Answer 4

您應該簡單地創建一個Action<Stream, object>代替：

static Action<Stream, object> GetWriteDelegateForType(Type type) 
{ 
    // get the actual generic method 
    var handlerObj = GetHandlerForType(type); 
    var methodInfo = handlerObj 
       .GetType() 
       .GetMethod("Write", new[] { typeof(MemoryStream), type }); 

    // but use (Stream, object) parameters instead 
    var streamArg = Expression.Parameter(typeof(Stream), "s"); 
    var objectArg = Expression.Parameter(typeof(object), "v"); 

    // this will cast object to T 
    var tCast = Expression.Convert(objectArg, type); 

    var handlerObjConstant = Expression.Constant(handlerObj); 
    var body = Expression.Call(handlerObjConstant, methodInfo, streamArg, tCast); 
    var lambda = Expression.Lambda<Action<Stream, object>>(body, streamArg, objectArg); 

    // and compile to an actual Action<Stream, object> 
    return lambda.Compile(); 
} 

然後你只需要調用它像一個普通的委託：

static void Write(MemoryStream s, object value) 
{ 
    var action = GetWriteDelegateForType(value.GetType()); 
    action(s, value); 
} 

這也將是不錯的主意緩存委託：

static readonly ConcurrentDictionary<Type, Action<Stream, object>> _cache = 
    new ConcurrentDictionary<Type, Action<Stream, object>>(); 

static void Write(MemoryStream s, object value) 
{ 
    var type = value.GetType(); 
    var action = _cache.GetOrAdd(type, GetWriteDelegateForType); 
    action(s, value); 
} 

Answer 5

添加一個其他答案，因爲這是一個比我的第一個明顯不同。

TLDR：添加非通用接口，創建一個字典來緩存類型的處理程序，使用非通用寫方法調用處理程序。

---

向ExplicitHandler中添加一個非通用接口，以便於在非泛型代碼中進行交互。

public interface IHandler 
{ 
    void Write(Stream s, object v); 
} 

實施ExplicitHandler非通用Write方法轉換爲T和調用通用寫

void IHandler.Write(Stream s, object v) 
    { 
     Write(s, (T)v); 
    } 

緩存在字典中重寫源

public class Test 
{ 
    static Dictionary<Type, IHandler> delegates = new Dictionary<Type, IHandler>(); 

    public static void Write(MemoryStream s, object value) 
    { 
     IHandler handler; 

     var type = value.GetType(); 
     if (!delegates.TryGetValue(type, out handler)) 
     { 
      handler = (IHandler)typeof(HandlerFactory).GetMethod(nameof(HandlerFactory.Create)).MakeGenericMethod(type).Invoke(null, null); 
      delegates[type] = handler; 
     } 

     handler.Write(s, value); 
    } 
} 

這裏的處理程序：http://pastebin.com/hmfj2Gv2