使用参数名称动态创建委托

本文关键字：创建 动态 参数 | 更新日期: 2023-09-27 18:26:06

嗨，我正在尝试创建一个函数，该函数动态创建一个委托，该委托具有与作为参数接收的MethodInfo相同的返回值和参数，而且这对于相同的参数名称非常重要！

到目前为止，我所做的是创建一个函数，该函数返回一个lambda，该lambda接收相同的参数类型，并具有与MethodInfo相同的返回值，但它没有参数名称：

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

有人对我该怎么做有什么建议吗？为了明确起见，我之所以关心参数名称，是因为我可以用参数名称激活委托，所以我可以这样调用它（欢呼="YAY！"，高度=3）（我的应用程序与Python集成，这就是我在没有DynamicInvoke的情况下能够做到这一点的原因，也是参数名称如此重要的原因以及为什么我写"="而不是"："）

使用参数名称动态创建委托

要动态创建委托，可以使用Reflection.Emit。由于委托在.Net中是特殊类型，因此创建它们的代码并不明显。以下内容基于Expression.Lambda()使用的方法的反射代码。在那里，它用于在没有可用的Action或Func委托（超过17个参数，或具有ref或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;
    }
}

如果您关心性能，可能需要创建某种缓存，这样就不会一遍又一遍地创建相同的委托类型。

代码中唯一的修改将是创建lambdaExpression:的行

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

但实际上您根本不需要处理Expression。Delegate.CreateDelegate()就足够了：

private static Delegate CreateDelegate(object instance, MethodInfo method)
{
    return Delegate.CreateDelegate(
        s_delegateTypeFactory.CreateDelegateType(method), instance, method);
}

我刚刚偶然发现了一种解决这个问题的好方法，对于静态方法的委托来说是这样的：

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

它使用这种扩展方法：

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

开源框架ImpromptuInterface（v5.6.7 via nuget）有一个DLR currying/partial apply实现，我认为只要不需要字面委托，它在这种情况下就会起作用。

以下是创建和调用它的c#版本：

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

所以jump不是一个字面上的委托，你不能反映它，但你可以直接调用它，就好像它是一个委托，它是DLR对象一样，所以我猜它在python中也会起作用。

相关文章：