Question

我正在尝试创建一个方法，该方法返回给定类型的委托，其中正文运行在函数中指定的某些代码。即。

    public Delegate GenerateDelegate(Type delegateType)
    {
        // create a delegate of type 'Type'
        // specify the code of this delegate
        // return the delegate object
    }

如果我知道类型，或至少参数＆amp;事先返回类型，我显然可以只返回一个类型的委托，一个匿名委托，用我想要的任何代码。但是，问题在于我希望这对任何类型的非泛型委托都有效，我希望能够使用委托类型所具有的参数，并返回正确的类型。

我已经了解了使用 ILGenerator.Emit（）或 CodeDOM 来实现此目的的不同选项。但是我可能想在返回的委托中执行相当复杂的操作，并且希望能够直接在C＃中对此进行编码，因为我不确定我是否可以使用IL或 CodeDOM 来实现此目的。作为伪解决方案，以与 Delegate.DynamicInvoke（params object []）相同的方式可以采用匿名参数，我想我能够做到这样的事情。< / p>

    public Delegate GenerateDelegate(Type delegateType)
    {
        return Delegate.CreateDelegate(delegateType, GetType().GetMethod("RunEvent"));
    }

    public static object RunEvent(params object[] parameters)
    {
        // some specified code, depending on contents of parameters
        return null;
    }

RunEvent（）可以将任意数量的参数作为对象数组，并返回对象。遗憾的是，这不起作用并抛出以下异常：

无法绑定到目标方法，因为其签名或安全透明度与委托类型的方法不兼容。

我认为对象数组参数应该与委托可能具有的任何参数组合兼容，但返回类型是对象，可能会返回一些与给定的 delegateType 不兼容的对象，或者如果 delegateType 返回void。这可能会导致一些问题。

对于我自己的用法，我在运行时知道所有参数和返回类型，并且可以检查这一点以确保一切都是安全的。有什么方法可以让我这样的工作吗？

Answer 1

是的，您可以沿着“原始”IL生成路线走下去。但如果方法的主体允许，请考虑使用expression-trees。

这是一个简单的例子，只返回返回类型的默认值，忽略所有参数（这只是一个玩具示例;真正的实现需要更复杂 - 例如，处理out参数：）

static Delegate CreateDelegate(Type[] parameterTypes, Type returnType)
{
   var parameters = parameterTypes.Select(Expression.Parameter)
                                  .ToArray();    

    var body = Expression.Default(returnType);    
    var lambda = Expression.Lambda(body, false, parameters);    
    return lambda.Compile();
}

用法：

Type[] parameterTypes = { typeof(string), typeof(double) };
var returnType = typeof(int);   

var del = CreateDelegate(parameterTypes, returnType);

//Output: System.Func`3[System.String,System.Double,System.Int32]
del.GetType().Dump();

//Output: 0
del.DynamicInvoke("abc", 5D).Dump();

Answer 2

我找到了解决问题的方法，但它确实需要我使用泛型。在某种程度上它是一个更安全的解决方案，因为我需要为生成器提供所请求的委托及其类型。

虽然解决方案并不是我所希望的，但它确实为我解决了问题，并回答了我原来的问题。然而，我将来可能不得不采用更复杂的解决方案。

如果有人能看到进一步的简化，请告诉我。

（我发现这要归功于Anis关于探索表达树的建议，因为它采用了类似的方法。）

public class DelegateGenerator<TDelegate, TReturn> 
    : GenBase<TDelegate, TReturn> where TDelegate : class
{
    public TReturn RunEvent() => runEvent();
}
public class DelegateGenerator<TDelegate, TReturn, T> 
    : GenBase<TDelegate, TReturn> where TDelegate : class
{
    public TReturn RunEvent(T a) => runEvent(a);
}
public class DelegateGenerator<TDelegate, TReturn, T1, T2> 
    : GenBase<TDelegate, TReturn> where TDelegate : class
{
    public TReturn RunEvent(T1 a, T2 b) => runEvent(a, b);
}
// etc

public abstract class GenBase<TDelegate, TReturn> where TDelegate : class
{
    public TDelegate GenerateDelegate()
    {
        var method = GetType().GetMethod("RunEvent");
        return Delegate.CreateDelegate(typeof(TDelegate), this, method) as TDelegate;
    }

    protected TReturn runEvent(params object[] objs)
    {
        // some code
        return (TReturn)result;
    }
}

用法：

public delegate bool myDelegate(int a, bool b);

var gen = new DelegateGenerator<myDelegate, bool, int, bool>();
var del = gen.GenerateDelegate();

var result = del(5, true);

创建具有未知参数和返回类型的委托

2 个答案: