你能從MethodInfo對象中得到一個Func <T>（或類似的）嗎？

Question

我知道，一般來說，使用反射會帶來性能影響。 （我本人不是反射的粉絲可言，其實，這是一個純粹的學術問題。）

假設存在某個類，看起來像這樣：這裏

public class MyClass { 
    public string GetName() { 
     return "My Name"; 
    } 
} 

包涵。我知道如果我有一個名爲x的MyClass實例，我可以撥打x.GetName()。此外，我可以將Func<string>變量設置爲x.GetName。

現在，這是我的問題。比方說我不知道知道上面的類叫做MyClass;我有一些對象，x，但我不知道它是什麼。我可以檢查，看看是否該對象是否具有GetName方法，通過這樣做：

MethodInfo getName = x.GetType().GetMethod("GetName"); 

假設getName不爲空。那麼我不能再進一步檢查getName.ReturnType == typeof(string)和getName.GetParameters().Length == 0，在這一點上，我不能肯定我的getName對象所代表的方法可能肯定以某種方式被轉換爲Func<string>？

我知道有一個MethodInfo.Invoke，我也知道我可以一直創建一個Func<string>，如：

Func<string> getNameFunc =() => getName.Invoke(x, null); 

我猜我問的是，如果有任何的路要走從一個MethodInfo對象到它所代表的實際方法，在處理中產生反射的性能代價，但在之後那個點能夠呼叫我（通過例如Func<string>或類似的東西）而沒有性能損失。

什麼我預想可能看起來是這樣的：（我認識到，不存在;我不知道是否有什麼像吧）

// obviously this would throw an exception if GetActualInstanceMethod returned 
// something that couldn't be cast to a Func<string> 
Func<string> getNameFunc = (Func<string>)getName.GetActualInstanceMethod(x); 

Answer 1

這種替換我以前的答案，因爲這一點，雖然這是一個稍長的路線 - 爲您提供了一個快速的方法調用，不像一些其他的答案，讓你通過不同的實例（如果你將遇到同一類型的多個實例）。如果你不想要，請查看底部的更新（或查看Ben M的答案）。

這是一個測試方法，你想要做什麼：

public class TestType 
{ 
    public string GetName() { return "hello world!"; } 
} 

[TestMethod] 
public void TestMethod2() 
{ 
    object o = new TestType(); 

    var input = Expression.Parameter(typeof(object), "input"); 
    var method = o.GetType().GetMethod("GetName", 
    System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public); 
    //you should check for null *and* make sure the return type is string here. 
    Assert.IsFalse(method == null && !method.ReturnType.Equals(typeof(string))); 

    //now build a dynamic bit of code that does this: 
    //(object o) => ((TestType)o).GetName(); 
    Func<object, string> result = Expression.Lambda<Func<object, string>>(
    Expression.Call(Expression.Convert(input, o.GetType()), method), input).Compile(); 

    string str = result(o); 
    Assert.AreEqual("hello world!", str); 
} 

一旦你建立委託一次 - 你可以在字典高速緩存它：

Dictionary<Type, Func<object, string>> _methods; 

所有然後你要做的就是將其添加到字典中，使用傳入對象的Type（來自GetType（））作爲鍵。在將來，你首先檢查你是否在字典中有一個準備好的委託（如果有的話，然後調用它），否則你先構建它，然後添加它，然後調用它。順便說一下，這是DLR爲其動態分配機制所做的一種非常高度簡化的版本（使用C＃術語，即使用'dynamic'關鍵字時）。

最後

如果像一些人所說，你只是想烤Func鍵直接綁定到你收到那麼對象你這樣做：

[TestMethod] 
public void TestMethod3() 
{ 
    object o = new TestType(); 

    var method = o.GetType().GetMethod("GetName", 
    System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public); 

    Assert.IsFalse(method == null && !method.ReturnType.Equals(typeof(string))); 

    //this time, we bake Expression.Constant(o) in. 
    Func<string> result = Expression.Lambda<Func<string>>(
    Expression.Call(Expression.Constant(o), method)).Compile(); 

    string str = result(); //no parameter this time. 
    Assert.AreEqual("hello world!", str); 
} 

注，儘管如此，一旦表達式樹被拋棄，你需要確保 o保持在範圍內，否則你可能會得到一些令人討厭的結果。最簡單的方法是在代理的整個生命週期內保持本地引用（可能在類實例中）。 （已移除的奔M的評論結果）

Answer 2

一休我頭上的方法將是使用動態。然後，您可以使這樣的事情：

if(/* This method can be a Func<string> */) 
{ 
    dynamic methodCall = myObject; 
    string response = methodCall.GetName(); 
} 

Answer 3

是的，這是可能的：

Func<string> func = (Func<string>) 
        Delegate.CreateDelegate(typeof(Func<string>), getName); 

Answer 4

你可以建立代表一個lambda調用這個方法和表達式目錄樹，然後Compile()它，以便進一步調用將只是與標準編譯調用一樣快。

另外，我基於一個偉大的MSDN文章，使用IL調用任何MethodInfo方式，因爲一旦生成的代碼比MethodInfo.DynamicInvoke更快產生的包裝寫this method了好一會兒前，有超過正常的幾乎沒有開銷呼叫。

Answer 5

這是我的答案，通過構建表達式樹。與其他答案不同，結果（getNameFunc）是綁定到原始實例的函數 - 無需將其作爲參數傳遞。

class Program 
{ 
    static void Main(string[] args) 
    { 
     var p = new Program(); 
     var getNameFunc = GetStringReturningFunc(p, "GetName"); 
     var name = getNameFunc(); 
     Debug.Assert(name == p.GetName()); 
    } 

    public string GetName() 
    { 
     return "Bob"; 
    } 

    static Func<string> GetStringReturningFunc(object x, string methodName) 
    { 
     var methodInfo = x.GetType().GetMethod(methodName); 

     if (methodInfo == null || 
      methodInfo.ReturnType != typeof(string) || 
      methodInfo.GetParameters().Length != 0) 
     { 
      throw new ArgumentException(); 
     } 

     var xRef = Expression.Constant(x); 
     var callRef = Expression.Call(xRef, methodInfo); 
     var lambda = (Expression<Func<string>>)Expression.Lambda(callRef); 

     return lambda.Compile(); 
    } 
} 

Answer 6

要做到這一點，最簡單的方法是通過Delegate.CreateDelegate：

Func<string> getNameFunc = (Func<string>) Delegate.CreateDelegate(
              typeof(Func<string>), x, getName); 

請注意，此結合getNameFunc到x，因此每個x你需要創建一個新的委託實例。此選項比基於Expression的示例複雜得多。但是，使用基於表達式的示例，可以創建一次Func<MyClass, string> getNameFuncForAny，您可以重複使用MyClass的每個實例。

要創建這樣一個getNameFuncForAny，你需要像

public Func<MyClass, string> GetInstanceMethod(MethodInfo method) 
{ 
    ParameterExpression x = Expression.Parameter(typeof(MyClass), "it"); 
    return Expression.Lambda<Func<MyClass, string>>(
     Expression.Call(x, method), x).Compile(); 
} 

的方法，您可以使用像這樣：

Func<MyClass, string> getNameFuncForAny = GetInstanceMethod(getName); 

MyClass x1 = new MyClass(); 
MyClass x2 = new MyClass(); 

string result1 = getNameFuncForAny(x1); 
string result2 = getNameFuncForAny(x2); 

如果你不想被束縛Func<MyClass, string>做，你可以定義

public TDelegate GetParameterlessInstanceMethod<TDelegate>(MethodInfo method) 
{ 
    ParameterExpression x = Expression.Parameter(method.ReflectedType, "it"); 
    return Expression.Lambda<TDelegate>(
     Expression.Call(x, method), x).Compile(); 
}