Wie erstelle ich einen Delegaten aus einer MethodInfo, wenn die Methodensignatur nicht vorher bekannt sein kann?

Question

Ich brauche eine Methode, die eine MethodInfo Instanz übernimmt, die eine nicht-generische statische Methode mit beliebiger Signatur darstellt und einen an diese Methode gebundenen Delegaten zurückgibt, der später mit der Methode Delegate.DynamicInvoke aufgerufen werden kann. Meine erste naive Versuch sah wie folgt aus:

using System; 
using System.Reflection; 

class Program 
{ 
    static void Main() 
    { 
     var method = CreateDelegate(typeof (Console).GetMethod("WriteLine", new[] {typeof (string)})); 
     method.DynamicInvoke("Hello world"); 
    } 

    static Delegate CreateDelegate(MethodInfo method) 
    { 
     if (method == null) 
     { 
      throw new ArgumentNullException("method"); 
     } 

     if (!method.IsStatic) 
     { 
      throw new ArgumentNullException("method", "The provided method is not static."); 
     } 

     if (method.ContainsGenericParameters) 
     { 
      throw new ArgumentException("The provided method contains unassigned generic type parameters."); 
     } 

     return method.CreateDelegate(typeof(Delegate)); // This does not work: System.ArgumentException: Type must derive from Delegate. 
    } 
} 

Ich hoffte, dass die MethodInfo.CreateDelegate Methode den Typ richtig delegieren herausfinden konnte selbst. Nun, offensichtlich kann es nicht. Wie erstelle ich eine Instanz von System.Type, die einen Delegaten mit einer Signatur darstellt, die der angegebenen MethodInfo Instanz entspricht?

Answer 1

können Sie System.Linq.Expressions.Expression.GetDelegateType Methode verwenden:

using System; 
using System.Linq; 
using System.Linq.Expressions; 
using System.Reflection; 

class Program 
{ 
    static void Main() 
    { 
     var writeLine = CreateDelegate(typeof(Console).GetMethod("WriteLine", new[] { typeof(string) })); 
     writeLine.DynamicInvoke("Hello world"); 

     var readLine = CreateDelegate(typeof(Console).GetMethod("ReadLine", Type.EmptyTypes)); 
     writeLine.DynamicInvoke(readLine.DynamicInvoke()); 
    } 

    static Delegate CreateDelegate(MethodInfo method) 
    { 
     if (method == null) 
     { 
      throw new ArgumentNullException("method"); 
     } 

     if (!method.IsStatic) 
     { 
      throw new ArgumentException("The provided method must be static.", "method"); 
     } 

     if (method.IsGenericMethod) 
     { 
      throw new ArgumentException("The provided method must not be generic.", "method"); 
     } 

     return method.CreateDelegate(Expression.GetDelegateType(
      (from parameter in method.GetParameters() select parameter.ParameterType) 
      .Concat(new[] { method.ReturnType }) 
      .ToArray())); 
    } 
} 

Es ist wahrscheinlich eine Copy-Paste-Fehler in der zweiten Prüfung für !method.IsStatic - Sie nicht ArgumentNullException es verwenden soll. Und es ist ein guter Stil, einen Parameternamen als Argument für ArgumentException bereitzustellen.

Verwenden Sie method.IsGenericMethod, wenn Sie alle generischen Methoden ablehnen möchten, und method.ContainsGenericParameters, wenn Sie nur generische Methoden mit unsubstituierten Typparametern ablehnen möchten.

Answer 2

Sie möchten System.Linq.Expressions

... 
using System.Linq.Expressions; 
... 

static Delegate CreateMethod(MethodInfo method) 
{ 
    if (method == null) 
    { 
     throw new ArgumentNullException("method"); 
    } 

    if (!method.IsStatic) 
    { 
     throw new ArgumentException("The provided method must be static.", "method"); 
    } 

    if (method.IsGenericMethod) 
    { 
     throw new ArgumentException("The provided method must not be generic.", "method"); 
    } 

    var parameters = method.GetParameters() 
          .Select(p => Expression.Parameter(p.ParameterType, p.Name)) 
          .ToArray(); 
    var call = Expression.Call(null, method, parameters); 
    return Expression.Lambda(call, parameters).Compile(); 
} 

und verwenden Sie es später wie folgt

var method = CreateMethod(typeof (Console).GetMethod("WriteLine", new[] {typeof (string)})); 
method.DynamicInvoke("Test Test");