Erstellen Delegierten dynamisch mit dem parameter-Namen

Hallo, ich versuche eine Funktion erstellen, die dynamisch erstellt einen Delegaten mit der gleichen Rückgabewert und die gleichen Parameter wie eine MethodInfo-es erhält als parameter und auch und dies ist sehr wichtig, den gleichen Parameternamen!

Was ich Tat, so weit ist erstellen Sie eine Funktion zurückgibt, die einen lambda-Ausdruck, der erhält die gleichen parameter-Typen und hat denselben Rückgabewert wie die MethodInfo-aber es muss nicht die Namen der parameter:

    static void Example()
    {
        Person adam = new Person();
        MethodInfo method = typeof(Person).GetMethod("Jump");
        Delegate result = CreateDelegate(adam, method);
        result.DynamicInvoke((uint)4, "Yeahaa");
    }

    private static Delegate CreateDelegate(object instance, MethodInfo method)
    {
        var parametersInfo = method.GetParameters();
        Expression[] expArgs = new Expression[parametersInfo.Length];
        List<ParameterExpression> lstParamExpressions = new List<ParameterExpression>();
        for (int i = 0; i < expArgs.Length; i++)
        {
            expArgs[i] = Expression.Parameter(parametersInfo[i].ParameterType, parametersInfo[i].Name);
            lstParamExpressions.Add((ParameterExpression)expArgs[i]);
        }

        MethodCallExpression callExpression = Expression.Call(Expression.Constant(instance), method, expArgs);
        LambdaExpression lambdaExpression = Expression.Lambda(callExpression, lstParamExpressions);

        return lambdaExpression.Compile();
    }

    private class Person
    {
        public void Jump(uint height, string cheer)
        {
            Console.WriteLine("Person jumped " + height + " "+ cheer);
        }
    }

Hat jemand irgendwelche Vorschläge, wie ich das tun kann?
Um deutlich zu machen, der Grund, mich interessieren die Namen der parameter ist, so wäre ich in der Lage zu aktivieren die Delegierten mit den parameter-Namen, so könnte ich es nennen, wie dies (cheer="YAY!', Höhe=3)
(Meine Anwendung ist integriert mit Python, das ist, wie ich in der Lage sein, es zu tun, ohne DynamicInvoke und das ist auch der Grund, warum die Namen der parameter sind so wichtig
und auch, warum ich schrieb '=' und nicht ':')

InformationsquelleAutor Uchiha Madara | 2012-02-29
  1. 7

    Dynamisch erstellen Sie einen Delegaten, die Sie verwenden können, Reflexion.Aussenden. Da die Delegierten sind spezielle Typen .Net, der code zu erstellen, ist es nicht ganz offensichtlich ist. Das folgende basiert auf reflektierter code von Methoden, die von Expression.Lambda(). Es dient zum erstellen von benutzerdefinierten Delegaten-Typen in Situationen, wo es keine Action oder Func Delegierten zur Verfügung (mehr als 17 Parameter oder Parameter mit ref oder out).

    class DelegateTypeFactory
{
    private readonly ModuleBuilder m_module;

    public DelegateTypeFactory()
    {
        var assembly = AppDomain.CurrentDomain.DefineDynamicAssembly(
            new AssemblyName("DelegateTypeFactory"), AssemblyBuilderAccess.RunAndCollect);
        m_module = assembly.DefineDynamicModule("DelegateTypeFactory");
    }

    public Type CreateDelegateType(MethodInfo method)
    {
        string nameBase = string.Format("{0}{1}", method.DeclaringType.Name, method.Name);
        string name = GetUniqueName(nameBase);

        var typeBuilder = m_module.DefineType(
            name, TypeAttributes.Sealed | TypeAttributes.Public, typeof(MulticastDelegate));

        var constructor = typeBuilder.DefineConstructor(
            MethodAttributes.RTSpecialName | MethodAttributes.HideBySig | MethodAttributes.Public,
            CallingConventions.Standard, new[] { typeof(object), typeof(IntPtr) });
        constructor.SetImplementationFlags(MethodImplAttributes.CodeTypeMask);

        var parameters = method.GetParameters();

        var invokeMethod = typeBuilder.DefineMethod(
            "Invoke", MethodAttributes.HideBySig | MethodAttributes.Virtual | MethodAttributes.Public,
            method.ReturnType, parameters.Select(p => p.ParameterType).ToArray());
        invokeMethod.SetImplementationFlags(MethodImplAttributes.CodeTypeMask);

        for (int i = 0; i < parameters.Length; i++)
        {
            var parameter = parameters[i];
            invokeMethod.DefineParameter(i + 1, ParameterAttributes.None, parameter.Name);
        }

        return typeBuilder.CreateType();
    }

    private string GetUniqueName(string nameBase)
    {
        int number = 2;
        string name = nameBase;
        while (m_module.GetType(name) != null)
            name = nameBase + number++;
        return name;
    }
}

    Wenn Sie sich sorgen über die performance, möchten Sie möglicherweise erstellen Sie einen cache von einigen Sortieren, so dass Sie nicht erstellen Sie die gleichen Delegaten-Typ über und über.

    Die einzige änderung im code wird die Zeile, die erstellt lambdaExpression:

    LambdaExpression lambdaExpression = Expression.Lambda(
    s_delegateTypeFactory.CreateDelegateType(method),
    callExpression, lstParamExpressions);

    Aber braucht man eigentlich nicht zu bewältigen Expressions bei allen. Delegieren.CreateDelegate() ist genug:

    private static Delegate CreateDelegate(object instance, MethodInfo method)
{
    return Delegate.CreateDelegate(
        s_delegateTypeFactory.CreateDelegateType(method), instance, method);
}
    • Danke, ich versuchte es heute und es hat Super geklappt!! Ich verstehe die meisten der code, aber ich konnte es nicht wirklich begreifen, was ist, dass Sie gerade mit dem Namen und nameBase, warum ist es gleich der Art Basis-name + Typ name, was ist die Nummer = 2 für? Jedenfalls danke Ihnen so sehr ich habe versucht, es für Tage
    • es ist nur ein Weg, um sicherzustellen, dass die Typ-name ist einzigartig, weil Sie nicht haben, können zwei Typen mit demselben Namen in derselben assembly. Und die Nummer 2 ist es so, dass die Namen sind wie PersonJump, PersonJump2, PersonJump3 usw.
    • Ich sehe, dass sehr schlau, danke! =]
    InformationsquelleAutor svick
  2. 1

    Ich habe gerade stolperte über einen schönen Weg, um dieses Problem zu lösen, es sieht aus wie dieses für die Delegierten eine statische Methode:

    private static Delegate CreateDelegate(MethodInfo method) {
    var paramTypes = method.GetParameters().Select(p => p.ParameterType);

    Type delegateType = Expression.GetDelegateType(paramTypes.Append(method.ReturnType).ToArray());

    return Delegate.CreateDelegate(delegateType, method, true);
}

    Verwendet diese extension Methode:

    public static IEnumerable<TSource> Append<TSource>(this IEnumerable<TSource> collection, TSource element) {
    if (collection == null) throw new ArgumentNullException("collection");

    foreach (TSource element1 in collection) yield return element1;
    yield return element;
}
    InformationsquelleAutor Herman
  3. 0

    Den open-source-framework ImpromptuInterface (v5.6.7 über nuget) hat das DLR currying/teilweise anwenden, - Implementierung, die ich denke würde in diesem Fall so lange, wie Sie nicht brauchen, eine wörtliche delegieren.

    Hier ist die c# - version zu erstellen und die Berufung auf Sie:

    dynamic jump =Impromptu.Curry(adam).Jump();
jump(cheer:"yay", height:(uint)3);

    So jump ist nicht eine wörtliche delegieren, Sie kann nicht reflektieren, aber Sie können es aufrufen, als ob es waren ein Delegierter und es ist ein DLR-Objekt, also meine Vermutung ist, dass es funktionieren würde, genau das gleiche in python.

    InformationsquelleAutor jbtule
Schreibe einen Kommentar