Come creare un delegato da un MethodInfo quando la firma del metodo non può essere conosciuta in anticipo?

Question

Ho bisogno di un metodo che prende un'istanza MethodInfo che rappresenta un metodo statico non generico con firma arbitraria e restituisce un delegato associato a quel metodo che potrebbe essere successivamente richiamato utilizzando il metodo Delegate.DynamicInvoke. Il mio primo tentativo ingenuo si presentava così:

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. 
    } 
} 

ho sperato che il metodo MethodInfo.CreateDelegate riusciva a capire il tipo delegato corretto se stessa. Beh, ovviamente non può. Quindi, come posso creare un'istanza di System.Type che rappresenta un delegato con una firma corrispondente all'istanza MethodInfo fornita?

Answer 1

È possibile utilizzare System.Linq.Expressions.Expression.GetDelegateType metodo:

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

v'è probabilmente un errore di copia-incolla nel 2 ° controllo per !method.IsStatic - non si deve usare ArgumentNullException lì. Ed è un buon stile fornire un nome parametro come argomento a ArgumentException.

Utilizzare method.IsGenericMethod se si desidera rifiutare tutti i metodi generici e method.ContainsGenericParameters se si desidera rifiutare solo i metodi generici con parametri di tipo non sostituiti.

Answer 2

Si consiglia di provare 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(); 
} 

e utilizzarlo in seguito come segue

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