c# - 一般存储和调用事件代理的委托(delegate)

Question

我正在尝试创建一个支持松散耦合的事件代理，同时仍允许开发人员使用熟悉的 += 语法和智能感知。我正在努力研究如何在不使用 DynamicInvoke 的情况下一般地调用委托(delegate)。

总体思路:

• 所有事件都在接口(interface)中定义，每个事件都需要一个从 EventInfoBase 派生的参数。

  public delegate void EventDelegate<in T>(T eventInfo) where T : EventInfoBase;
  

• 在订阅者端，客户端向 Windsor 容器请求实现事件接口(interface)的实例。 Windsor 返回一个拦截所有 += (add_xxx) 和 -= (remove_xxx) 调用的代理。存储类型和委托(delegate)信息以供将来在触发事件时查找和执行。目前委托(delegate)存储为 Delegate，但更愿意将其存储为 EventDelegate 之类的东西。

• 在发布者端，发布者向事件代理注册为事件接口(interface)的来源。事件代理通过反射使用类型为 EventDelegate 的委托(delegate)订阅每个事件。

• 当触发事件时，事件代理会查找任何合适的委托(delegate)并执行它们。

问题:

使用 EventInfoBase 基类向发布者添加事件处理程序是对逆变的合法使用。但事件代理无法将客户端订阅存储为 EventDelegate 。 Eric Lippert 在 blog post 中解释了原因.

关于如何存储客户端订阅(委托(delegate))以便稍后可以在不使用 DynamicInvoke 的情况下调用它们的任何想法？

更新了更多详细信息:

订阅者向事件代理请求事件接口(interface)，然后根据需要订阅事件。

// a simple event interface
public class EventOneArgs : EventInfoBase { }
public class EventTwoArgs : EventInfoBase { }
public interface ISomeEvents
{
  event EventDelegate<EventOneArgs> EventOne;
  event EventDelegate<EventTwoArgs> EventTwo;
}

// client gets the event broker and requests the interface
// to the client it looks like a typical object with intellisense available
IWindsorContainer cont = BuildContainer();
var eb = cont.Resolve<IEventBroker>();
var service = eb.Request<ISomeEvents>();
service.EventOne += new EventDelegate<EventOneArgs>(service_EventOne);
service.EventTwo += new EventDelegate<EventTwoArgs>(service_EventTwo);

在幕后，事件代理对事件接口(interface)一无所知，它返回该接口(interface)的代理。所有 += 调用都被拦截，订阅添加了委托(delegate)字典。

public T Request<T>(string name = null) where T : class
{
  ProxyGenerator proxygenerator = new ProxyGenerator();
  return proxygenerator.CreateInterfaceProxyWithoutTarget(typeof(T), 
            new EventSubscriptionInterceptor(this, name)) as T;
}

public void Intercept(IInvocation invocation)
{
  if (invocation.Method.IsSpecialName)
  {
    if (invocation.Method.Name.Substring(0, s_SubscribePrefix.Length) == s_SubscribePrefix) // "add_"
    {
       // DeclaringType.FullName will be the interface type
       // Combined with the Name - prefix, it will uniquely define the event in the interface
       string uniqueName = invocation.Method.DeclaringType.FullName + "." + invocation.Method.Name.Substring(s_SubscribePrefix.Length);
       var @delegate = invocation.Arguments[0] as Delegate; 
       SubscirptionMgr.Subscribe(uniqueName, @delegate);
       return;
    }
    // ...
  }
}

存储在 SubscriptionManager 中的委托(delegate)是 EventDelegate 类型，其中 T 是事件定义的派生类型。

出版商:发布者注册为事件接口(interface)的来源。目标是消除显式调用事件代理的需要，并允许使用 EventName(args) 的典型 C# 语法。

public class SomeEventsImpl : ISomeEvents
{
   #region ISomeEvents Members
   public event Ase.EventBroker.EventDelegate<EventOneArgs> EventOne;
   public event Ase.EventBroker.EventDelegate<EventTwoArgs> EventTwo;
   #endregion

   public SomeEventsImpl(Ase.EventBroker.IEventBroker eventBroker)
   {
      // register as a source of events
      eventBroker.RegisterSource<ISomeEvents, SomeEventsImpl>(this);
   }

   public void Fire_EventOne()
   {
      if (EventOne != null)
      {
         EventOne(new EventOneArgs());
      }
   }
}

事件代理使用反射来订阅接口(interface)中的所有事件 (AddEventHandler) 和一个公共(public)处理程序。我还没有尝试组合处理程序。我创建了一个包装类，以防在触发事件时需要可用的其他信息，例如类型。

public void RegisterSource<T, U>(U instance)
   where T : class
   where U : class
{
   T instanceAsEvents = instance as T;
   string eventInterfaceName = typeof(T).FullName;
   foreach (var eventInfo in instanceAsEvents.GetType().GetEvents())
   {
      var wrapper = new PublishedEventWrapper(this, eventInterfaceName + "." + eventInfo.Name);
      eventInfo.AddEventHandler(instance, wrapper.EventHandler);
   }
}

class PublishedEventWrapper
{
   private IEventPublisher m_publisher = null;
   private readonly EventDelegate<EventInfoBase> m_handler;

   private void EventInfoBaseHandler(EventInfoBase args)
   {
      if (m_publisher != null)
      {
         m_publisher.Publish(this, args);
      }
   }

   public PublishedEventWrapper(IEventPublisher publisher, string eventName)
   {
      m_publisher = publisher;
      EventName = eventName;
      m_handler = new EventDelegate<EventInfoBase>(EventInfoBaseHandler);
   }

   public string EventName { get; private set; }
   public EventDelegate<EventInfoBase> EventHandler
   {
      get { return m_handler; }
   }
}

我一直在努力解决的问题在于发布。 Publish 方法查找事件的委托(delegate)并需要执行它们。由于 DynamicInvoke 的性能问题，我想将委托(delegate)转换为正确的 EventDelegate 形式并直接调用它，但还没有找到实现它的方法。

我当然学到了很多试图解决这个问题的方法，但时间不多了。我可能遗漏了一些简单的东西。我已经尝试将委托(delegate)包装在另一个(动态生成的)本质上看起来像:

private static void WrapDelegate(Delegate d, DerivedInfo args)
{
   var t = d as EventDelegate<DerivedInfo>;
   if (t != null)
   {
      t(args);
   }
}

如有任何指导，我们将不胜感激。

Answer 1

Any ideas of how I could store the client subscriptions (delegates) so they can be called later without the use of DynamicInvoke?

你可以使用 Dictionary<Type, Delegate> ，然后适本地转换:

public void Subscribe<T>(EventDelegate<T> handler) where T : EventInfoBase
{
    Delegate existingHandlerPlain;
    // We don't actually care about the return value here...
    dictionary.TryGetValue(typeof(T), out existingHandlerPlain);
    EventDelegate<T> existingHandler = (EventDelegate<T>) existingHandlerPlain;
    EventDelegate<T> newHandler = existingHandler + handler;
    dictionary[typeof(T)] = newHandler;
}

public void Publish<T>(EventInfo<T> info) where T : EventInfoBase
{
    Delegate handlerPlain;
    if (dictionary.TryGetValue(typeof(T), out handlerPlain))
    {
        EventDelegate<T> handler = (EventDelegate<T>) handlerPlain;
        handler(info);
    }
}

类型转换应该始终是安全的，因为您自己管理内容。

不过，如果您尝试组合实际上属于不同类型的事件处理程序，您仍然可能会遇到方差问题。如果这是一个问题，您需要明确使用 List<EventHandler<T>>而不是使用“正常”的组合操作。