使用 MulticastDelegate 作为参数，同时避免 DynamicInvoke

Question

我有一个MulticastDelegate，它可以引用具有相同签名的多个（旧版）代表之一。例如：

public delegate void ObjectCreated(object sender, EventArgs args);
public delegate void ObjectDeleted(object sender, EventArgs args);
//...

然后使用这些委托来定义事件：

public event ObjectCreated ObjectWasCreated;
public event ObjectDeleted ObjectWasDeleted;

然后我有一个方法接受MulticastDelegate，我用它来做一些常见的检查：

void DispatchEvent(MulticastDelegate handler, object sender, EventArgs args)
{
    if (handler != null)
    {
        // ...
        handler.DynamicInvoke(sender, args);
    }
}

从定义事件的类的其他方法中调用：

DispatchEvent(ObjectWasCreated, sender, args);
DispatchEvent(ObjectWasDeleted, sender, args);

有没有更简洁的方法来避免 DynamicInvoke？

Answer 1

这是我的无反射解决方案。它基本上实现了一个多播委托作为一个列表。代码少？不。更好的性能？我不知道。清洁器？嗯。

public delegate void ObjectCreated(object sender, EventArgs args);
public delegate void ObjectDeleted(object sender, EventArgs args);

public event ObjectCreated ObjectWasCreated
{
    add
    {
        m_ObjectCreatedSubscribers.Add(value.Invoke);
    }
    remove
    {
        m_ObjectCreatedSubscribers.RemoveAll(e => e.Target.Equals(value));
    }
}
public event ObjectDeleted ObjectWasDeleted
{
    add
    {
        m_ObjectDeletedSubscribers.Add(value.Invoke);
    }
    remove
    {
        m_ObjectDeletedSubscribers.RemoveAll(e => e.Target.Equals(value));
    }
}

private List<Action<object, EventArgs>> m_ObjectCreatedSubscribers = new List<Action<object, EventArgs>>();
private List<Action<object, EventArgs>> m_ObjectDeletedSubscribers = new List<Action<object, EventArgs>>();

void DispatchEvent(List<Action<object, EventArgs>> subscribers, object sender, EventArgs args)
{
    foreach (var subscriber in subscribers)
        subscriber(sender, args);
}

Answer 2

一种简单的替代方法是使用 Action<,> 或 EventHandler 等内置类型，而不是自定义委托，这样您就可以获得强类型。

public static event Action<object, EventArgs> ObjectWasCreated;
public static event Action<object, EventArgs> ObjectWasDeleted;  

void DispatchEvent(Action<object, EventArgs> handler, object sender, EventArgs args) 
{
    if (handler != null)
    {
        // ...
        handler(sender, args);
    }
}

或

public static event EventHandler ObjectWasCreated;
public static event EventHandler ObjectWasDeleted;  

void DispatchEvent(EventHandler handler, object sender, EventArgs args) 
{
    if (handler != null)
    {
        // ...
        handler(sender, args);
    }
}

现在您的方法调用将很简单。

DispatchEvent(ObjectWasCreated, sender, args);
DispatchEvent(ObjectWasDeleted, sender, args);

但这大多不是一个好的解决方案。

你可以用dynamic，还是比DynamicInvoke好很多：

void DispatchEvent(MulticastDelegate handler, object sender, EventArgs args) 
{
    if (handler != null)
    {
        // ...
        ((dynamic)handler)(sender, args);
    }
}

或者可能是泛型：

void DispatchEvent<T>(T handler, object sender, EventArgs args) 
{
    if (handler != null)
    {
        // ...
        ((dynamic)handler)(sender, args);
    }
}

我做了一个小的性能比较，发现 dynamic 实际上太好了：

一百万次尝试

MulticastDelegate + 动态（第一个示例）=> 40 毫秒

通用 + 动态（第二个示例）=> 90 毫秒

MulticastDelegate + DynamicInvoke（最初给出）=> 940 毫秒

Answer 3

你可以这样做：

void DispatchEvent(MulticastDelegate handler, object sender, EventArgs args)
{
    EventHandler eventHandler = 
        (EventHandler)Delegate.CreateDelegate(typeof(EventHandler), handler.GetType().GetMethod("Invoke"));

    eventHandler(sender, args);
}

不过，我不确定这是否会比使用 DynamicInvoke 更快。

您必须在某处使用反射。如果可以保证每个代表只有一个订阅者，那么您可以在创建 EventHandler 时直接使用 Delegate.Method 属性，但由于它们是事件，它们可能有多个订阅者...