如何在 C# 中按类型创建动态委托对象？

Question

假设我有一个type，我知道它是从Delegate 类型派生的。我想创建一个这种类型的对象，该对象包装一个接受任意参数并返回正确返回类型的对象的匿名委托：

var retType = type.GetMethod("Invoke").ReturnType;
var obj = Delegate.CreateDelegate(type, delegate(object[] args) {
    ...
    if (retType != typeof(void))
      ... somehow create object of type retType and return it ...
});

显然这不会编译，因为CreateDelegate 期望MethodInfo 作为第二个参数。我怎样才能正确地做到这一点？

更新：关于我正在努力实现的目标的更多信息。有两个应用程序正在运行 - 浏览器中的客户端和 C# 中的服务器。浏览器能够通过将参数序列化为 JSON 并通过网络发送调用（如在 RPC 中）来调用服务器端的远程函数。这已经有效，但我想添加对回调的支持。例如：

JavaScript（客户端）：

function onNewObject(uuid) { console.log(uuid); }
server.notifyAboutNewObjects(onNewObject);

C#（服务器）：

void notifyAboutNewObjects(Action<string> callback) {
  ...
  callback("new-object-uuid");
  ...
}

中间件代码将接收来自浏览器的调用，并需要生成虚假的callback 委托，该委托实际上会将对callback 的调用发送回浏览器并阻塞线程直到它完成。发送/接收的代码已经有了，我只是纠结于如何生成一个通用委托，它将简单地将所有参数放入一个数组并将它们传递给发送代码。

更新：如果有人可以编写代码在运行时生成这样的委托（例如使用DynamicMethod），我会认为这是一个有效的答案。我只是没有足够的时间来学习如何做到这一点，并希望有经验的人能够足够快地编写此代码。本质上，代码应该只接受任意委托参数（列表和类型在运行时可用），将它们放入数组并调用泛型方法。泛型方法将始终返回 object，如果函数返回 void，则应将其转换为相应的返回类型或忽略。

更新：我创建了一个小型测试程序来演示我需要什么：

using System;
using System.Reflection;

namespace TestDynamicDelegates
{
    class MainClass
    {
        // Test function, for which we need to create default parameters.
        private static string Foobar(float x, Action<int> a1, Func<string, string> a2) {
            a1(42);
            return a2("test");
        }

        // Delegate to represent generic function.
        private delegate object AnyFunc(params object[] args);

        // Construct a set of default parameters to be passed into a function.
        private static object[] ConstructParams(ParameterInfo[] paramInfos)
        {
            object[] methodParams = new object[paramInfos.Length];
            for (var i = 0; i < paramInfos.Length; i++) {
                ParameterInfo paramInfo = paramInfos[i];
                if (typeof(Delegate).IsAssignableFrom(paramInfo.ParameterType)) {
                    // For delegate types we create a delegate that maps onto a generic function.
                    Type retType = paramInfo.ParameterType.GetMethod("Invoke").ReturnType;

                    // Generic function that will simply print arguments and create default return value (or return null
                    // if return type is void).
                    AnyFunc tmpObj = delegate(object[] args) {
                        Console.WriteLine("Invoked dynamic delegate with following parameters:");
                        for (var j = 0; j < args.Length; j++)
                            Console.WriteLine("  {0}: {1}", j, args[j]);
                        if (retType != typeof(void))
                            return Activator.CreateInstance(retType);
                        return null;
                    };

                    // Convert generic function to the required delegate type.
                    methodParams[i] = /* somehow cast tmpObj into paramInfo.ParameterType */
                } else {
                    // For all other argument type we create a default value.
                    methodParams[i] = Activator.CreateInstance(paramInfo.ParameterType);
                }
            }

            return methodParams;
        }

        public static void Main(string[] args)
        {
            Delegate d = (Func<float, Action<int>,Func<string,string>,string>)Foobar;

            ParameterInfo[] paramInfo = d.Method.GetParameters();
            object[] methodParams = ConstructParams(paramInfo);
            Console.WriteLine("{0} returned: {1}", d.Method.Name, d.DynamicInvoke(methodParams));
        }
    }
}

Answer 1

我编写了一个开源 PCL 库，名为 Dynamitey（在 nuget 中），它使用 C# DLR 执行各种动态操作。 .

它特别有一个名为Dynamic.CoerceToDelegate(object invokeableObject, Type delegateType) 的静态方法，它基本上包装了DynamicObject 或更通用的委托的动态调用，使用CompiledExpressions (source) 的委托的特定类型。

使用 System.Dynamic 您可以创建一个可调用对象：

public class AnyInvokeObject:DynamicObject{
    Func<object[],object> _func;
    public AnyInvokeObject(Func<object[],object> func){
       _func = func;
    }
    public override bool TryInvoke(InvokeBinder binder, object[] args, out object result){
       result = _func(args);
       return true;
    }
}

然后在您的示例中：

var tmpObj = new AnyInvokeObject(args => {
                     Console.WriteLine("Invoked dynamic delegate with following parameters:");
                     for (var j = 0; j < args.Length; j++)
                         Console.WriteLine("  {0}: {1}", j, args[j]);
                     if (retType != typeof(void))
                         return Activator.CreateInstance(retType);
                     return null;
                });
methodParams[i] = Dynamic.CoerceToDelegate(tmpObj, paramInfo.ParameterType);

Answer 2

您可以查看SignalR 的源代码，或者直接使用它。

在浏览器中注册一个服务器可以调用的函数

var connection = $.hubConnection();
var yourHubProxy = connection.createHubProxy('yourHub');
yourHubProxy.on('addMessageToConsole', function (message) {
  console.log(message);
});

在服务器上

public class YourHub : Hub
{
    public void SendMessage(string message)
    {
        Clients.All.addMessageToConsole(message);
    }
}

有关更多示例，请参阅here。

Answer 3

没有代表的解决方案怎么样？ （警告：泛滥的伪代码）

class AbstractServerToClientMessage {
     public virtual string ToJSON();
}
class OnNewObjectMessage: AbstractServerToClientMessage {...}
class OnSomethingElseHappenedMessage: AbstractServerToClientMessage {...}

void NotifyClient(AbstractServerToClientMessage message)

event OnNewObject;
event OnSomethingElseHappened;

void notifyAboutNewObjects() {
    ...
    OnNewObject += NotifyClient;
    ...
}

void AddNewObject(SomeObject obj) {
    OnNewObjectMessage message(obj);
    OnNewObject(message);
    // actually add the object
}

消息无论如何都会被序列化，那何必呢？多态性将负责其余的工作。唯一的要求是有一组与每种事件类型相对应的消息。

可以通过写入AbstractServerToClientMessage中的某个字段来实现返回值。

---

或者，您实际上可以让一个具有固定签名的委托人接受类似的AbstractServerToClientMessage。同样，多态性（+ 用于反序列化的类工厂）将允许将其转换为正确的消息类型。