如何使用 lambda 来创建一个新的 EventHandler？

Question

似乎我应该在这里拥有我需要的一切，但实现它的细节让我发疯。

我有一个静态实用程序方法，它接受一个 Web 服务客户端对象，从中提取指定的 EventInfo，并应该向该事件添加一些处理程序，本质上是 Web 服务调用完成时的回调。问题是，由于任何给定的事件本质上都有自己的处理程序重载（WCF 生成的代码为每个方法和对应的事件提供了唯一的 SomeMethodCompletedEventArgs），我不知道如何实现这一点。

我有两个要附加的处理程序，第一个只是一个 lambda 函数：

(obj, args) => task.Complete()

所以我想做的就是这么简单：

eventInfo.AddEventHandler(client, new EventHandler((obj, args) => task.Complete()));

但是，这会生成运行时 InvalidCastException，因为 eventInfo 需要一个 EventHandler<SomeMethodCompletedEventArgs>，而不是普通的 EventHandler。我相信这意味着我需要以某种方式使用 eventInfo.EventHandlerType 动态创建 EventHandler 委托，但我还没有想出将它与 lambda 函数结合起来，或者以其他方式创建一个真正不 care 正在使用 EventArgs 的什么特殊口味。

我发现的唯一解决方法是创建一个通用模板参数，用于传递特定事件参数类型。这使我能够去：

eventInfo.AddEventHandler(client, new EventHandler<E>(...));

其中 E 是有问题的参数。然而，这显然很笨拙，当提取的 eventInfo 应该告诉我们所有我们需要知道的事情时，必须传递它似乎是错误的。

值得注意的是，我为 Xamarin 使用了一个稍微受限的 PCL 框架，它显然不包括我在相关问题中提到的静态 Delegate.CreateDelegate() 方法。不过，我可以访问 Activator，这应该涵盖大部分相同的基础。

Answer 1

在您提供的示例中，您应该能够只删除显式委托构造函数：

eventInfo.AddEventHandler(client, (obj, args) => task.Complete());

通过让 C# 为您推断委托类型，它应该准确地创建参数所需的正确委托类型。

如果这不能解决您的具体问题，请提供 a good, minimal, complete code example 可靠地重现问题，并清楚、准确地解释为什么上述方法不起作用。

顺便说一句，很难从您发布的小代码中判断出来，但是有一个明确的 AddEventHandler() 方法是不寻常的。通常，class 会简单地公开一个事件，您会使用 += 语法来订阅事件处理程序。

编辑：

根据您的评论，我了解到 API 要求您遵守动态提供的事件签名。就我个人而言，我认为这种设计很愚蠢，但我想你会坚持下去，大概是由于 Xamarin 框架的设计。

严格按照既定目标——即给定一个EventHandler实例，生成一个新的委托实例，其类型与运行-时间提供的Type实例相匹配— 以下方法应该适合您：

static Delegate CreateDelegate(Type type, EventHandler handler)
{
    return (Delegate)type.GetConstructor(new [] { typeof(object), typeof(IntPtr) })
        .Invoke(new [] { handler.Target, handler.Method.MethodHandle.GetFunctionPointer() });
}

用法示例：

eventInfo.AddEventHandler(client,
    CreateDelegate(eventInfo.EventHandlerType, (obj, args) => task.Complete());

你可以把上面写成一个扩展方法来简化调用（你没有说client是什么类型，所以我就把它写成object作为例子）：

public static void AddEventHandler(this EventInfo eventInfo, object client, EventHandler handler)
{
        object eventInfoHandler = eventInfo.EventHandlerType
            .GetConstructor(new[] { typeof(object), typeof(IntPtr) })
            .Invoke(new[] { handler.Target, handler.Method.MethodHandle.GetFunctionPointer() });

        eventInfo.AddEventHandler(client, (Delegate)eventInfoHandler);
}

用法示例：

eventInfo.AddEventHandler(client, (obj, args) => task.Complete());

如果您担心 API 自己的 AddEventHandler() 方法在某些时候可能会以导致 C# 编译器 select 它的实现而不是扩展方法，或者当然如果它今天这样做（假设只有一个 AddEventHandler() 方法重载，第二个参数为 Delegate，上面的方法就可以工作，但是同样......缺乏一个好的, minimal, complete 代码示例暴露一点的成本 "magic" :)).

最后，确定了一个可行的解决方案后，我便能够在 Stack Overflow 中搜索类似的问题并找到了这个问题，您可以争辩说您自己的问题是重复的：Using reflection to specify the type of a delegate (to attach to an event)?

我决定继续在这里编辑我自己的答案，而不是仅仅提议关闭你的问题，因为对另一个问题的答案并没有真正提供我认为优雅或易于使用的东西例如。

Answer 2

事实证明这并不难，但确实需要一些代码和一些反思。

基本思想是将处理程序包装在由事件类型

参数化的通用 class 中

HandlerFor<T> : IDisposable where T : EventArgs.

这个 class 然后有一个私有成员函数匹配所需的事件处理程序签名：

void Handle(object sender, T eventArgs)

它将在构建时注册，在处置时取消注册，并且每当事件发生时，它将调用在其构造函数中提供给它的给定 Action。

为了隐藏实现细节，并仅公开一个 IDisposable 作为受控事件处理程序生命周期范围和注销的句柄，我将其包装在 EventHandlerRegistry class 中。如果需要，这也将允许在未来添加改进，例如构建工厂委托而不是重复调用 Activator.CreateInstance() 来构建 HandleFor 实例。

看起来像这样：

public class EventHandlerRegistry : IDisposable
{
    private ConcurrentDictionary<Type, List<IDisposable>> _registrations;

    public EventHandlerRegistry()
    {
        _registrations = new ConcurrentDictionary<Type, List<IDisposable>>();
    }

    public void RegisterHandlerFor(object target, EventInfo evtInfo, Action eventHandler)
    {
        var evtType = evtInfo.EventHandlerType.GetGenericArguments()[0];
        _registrations.AddOrUpdate(
            evtType,
            (t) => new List<IDisposable>() { ConstructHandler(target, evtType, evtInfo, eventHandler) },
            (t, l) => { l.Add(ConstructHandler(target, evtType, evtInfo, eventHandler)); return l; });
    }

    public IDisposable CreateUnregisteredHandlerFor(object target, EventInfo evtInfo, Action eventHandler)
    {
        var evtType = evtInfo.EventHandlerType.GetGenericArguments()[0];
        return ConstructHandler(target, evtType, evtInfo, eventHandler);
    }

    public void Dispose()
    {
        var regs = Interlocked.Exchange(ref _registrations, null);
        if (regs != null)
        {
            foreach (var reg in regs.SelectMany(r => r.Value))
                reg.Dispose();
        }
    }

    private IDisposable ConstructHandler(object target, Type evtType, EventInfo evtInfo, Action eventHandler)
    {
        var handlerType = typeof(HandlerFor<>).MakeGenericType(evtType);
        return Activator.CreateInstance(handlerType, target, evtInfo, eventHandler) as IDisposable;
    }

    private class HandlerFor<T> : IDisposable where T : EventArgs
    {
        private readonly Action _eventAction;
        private readonly EventInfo _evtInfo;
        private readonly object _target;
        private EventHandler<T> _registeredHandler;

        public HandlerFor(object target, EventInfo evtInfo, Action eventAction)
        {
            _eventAction = eventAction;
            _evtInfo = evtInfo;
            _target = target;
            _registeredHandler = new EventHandler<T>(this.Handle);
            _evtInfo.AddEventHandler(target, _registeredHandler);
        }

        public void Unregister()
        {
            var registered = Interlocked.Exchange(ref _registeredHandler, null);
            if (registered != null)
                // Unregistration is awkward: 
                // doing `RemoveEventHandler(_target, registered);` won't work.
                _evtInfo.RemoveEventHandler(_target, new EventHandler<T>(this.Handle));
        }

        private void Handle(object sender, T EventArgs)
        {
            if (_eventAction != null)
                _eventAction();
        }

        public void Dispose()
        {
            Unregister();
        }
    }
}

它支持以非常透明的方式干净地添加和删除事件处理程序。注意：这还没有以推荐的方式实现 IDisposable。您必须自己添加终结器和 Dispose(bool isFinalizing)。

这显示了它的用法示例：

public class MyArgs1 : EventArgs
{
    public string Value1;
}

public class MyEventSource
{
    public event EventHandler<MyArgs1> Args1Event;

    public EventInfo GetEventInfo()
    {
        return this.GetType().GetEvent("Args1Event");
    }

    public void FireOne()
    {
        if (Args1Event != null)
            Args1Event(this, new MyArgs1() { Value1 = "Bla " });
    }
}

class Program
{
    public static void Main(params string[] args)
    {
        var myEventSource = new MyEventSource();
        using (var handlerRegistry = new EventHandlerRegistry())
        {
            handlerRegistry.RegisterHandlerFor(
                myEventSource,
                myEventSource.GetEventInfo(),
                () => Console.WriteLine("Yo there's some kinda event goin on"));
            handlerRegistry.RegisterHandlerFor(
                myEventSource,
                myEventSource.GetEventInfo(),
                () => Console.WriteLine("Yeah dawg let's check it out"));

            myEventSource.FireOne();
        }
        myEventSource.FireOne();
    }
}

当运行时，输出如下：

如何使用 lambda 来创建一个新的 EventHandler？

How can one use a lambda to create a new EventHandler?

c#

wcf

xamarin