Question

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

一般理念：

所有事件都在接口中定义，每个事件都需要一个派生自EventInfoBase的参数。
```
public delegate void EventDelegate<in T>(T eventInfo) where T : EventInfoBase;
```
在订阅者端，客户端向Windsor容器请求实现事件接口的实例。 Windsor返回一个拦截所有+ =（add_xxx）和 - =（remove_xxx）调用的代理。存储类型和委托信息，以便在触发事件时进行查找和执行。目前，委托存储为Delegate，但更喜欢将其存储为EventDelegate。
在发布者方面，发布者向事件代理注册为事件接口的源。事件代理通过反射，使用EventDelegate＆lt; EventInfoBase＆gt;类型的委托订阅每个事件。
当事件被触发时，事件代理会查找任何适当的代理并执行它们。

问题：

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

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

更新了其他详细信息：

订阅者向事件代理询问事件接口，然后根据需要订阅事件。

// 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);

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

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中的委托的类型为EventDelegate＆lt; T＆gt;，其中T是事件定义的派生类型。

出版商：发布者注册为事件接口的源。目标是消除显式调用事件代理并允许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());
      }
   }
}

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

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方法查找事件的委托并需要执行它们。由于DynamicInvoke的性能问题，我想将委托转换为正确的EventDelegate＆lt; T＆gt;形成并直接调用它，但还没有想出办法。

我确实学到了很多东西，但是我已经没时间了。我可能错过了一些简单的东西。我已经尝试将委托包装在另一个（动态生成的）中，基本上看起来像：

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

任何指导都将不胜感激。

Answer 1

关于如何存储客户端订阅（委托）的任何想法，以便以后可以在不使用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>>而不是使用“正常”组合操作。

Answer 2

包装委托的解决方案：

我确实设法找到一种方法来使用已知类型的委托来包装泛型委托。这允许使用SomeDelegate（args）的标准调用约定。此解决方案接受由以下内容定义的通用委托：

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

泛型委托由具有已知签名的委托包装，该签名可由基础结构代码调用。我还没有验证这种方法的表现。调用MethodInfo.Invoke的成本是在订阅事件时产生的。触发事件的成本是DelegateWrapper中的代码。

  private static EventDelegate<EventInfoBase> DelegateWrapper<T>(Delegate @delegate) where T : EventInfoBase
  {
     return (o =>
        {
           var t = @delegate as EventDelegate<T>;
           var args = o as T;
           if (t != null && o != null)
           {
              t(args);
           }
        }
     );
  }

  private static readonly MethodInfo s_eventMethodInfo = typeof(EventSubscriptionInterceptor).GetMethod("DelegateWrapper", BindingFlags.NonPublic | BindingFlags.Static);

  private EventDelegate<EventInfoBase> GenerateDelegate(Delegate d)
  {
     MethodInfo closedMethod = s_eventMethodInfo.MakeGenericMethod(d.Method.GetParameters()[0].ParameterType);
     var newDel = closedMethod.Invoke(null, new object[] { d }) as EventDelegate<EventInfoBase>;
     return newDel;
  }

至少这给了我一个松散耦合的事件代理的工作原型，其中“主要是”C＃语法。

通常存储和调用事件代理的代理

2 个答案: