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

Brauche ich eine Methode, die eine MethodInfo Instanz repräsentiert eine nicht-generische statische Methode mit beliebigen Signatur und gibt einen Delegaten gebunden, die Methode, die später aufgerufen werden, mit Delegate.DynamicInvoke Methode. Mein Erster naiver Versuch sah so 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.
    }
}

Hoffte ich, dass die MethodInfo.CreateDelegate Methode könnte herausfinden der richtigen Delegaten-Typ selbst. Nun, offensichtlich kann es nicht. Also, wie erstelle ich eine Instanz von System.Type Vertretung eines Delegierten mit einer Signatur passend zu den bereitgestellten MethodInfo Instanz?

InformationsquelleAutor der Frage Zakharia Stanley | 2013-05-03

  1. 30

    Können Sie System.Linq -.Ausdrücke.Ausdruck.GetDelegateType Methode:

    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 wohl ein copy-paste-Fehler in der 2. Prüfung für !method.IsStatic - sollten Sie nicht verwenden ArgumentNullException es. Und es ist ein guter Stil, um eine parameter-name als argument an ArgumentException.

    Verwenden method.IsGenericMethod wenn Sie möchten, dass alle generische Methoden und method.ContainsGenericParameters wenn Sie ablehnen möchten nur generische Methoden haben unsubstituted Typ-Parameter.

    InformationsquelleAutor der Antwort Oksana Gimmel

  2. 3

    Möchten Sie vielleicht, um zu versuchen, System.LinQ -.Ausdrücke

    ...
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 als folgende

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

    InformationsquelleAutor der Antwort Khoa Nguyen

Schreibe einen Kommentar