在 C# 中转发事件

Question

我正在使用一个在 C# 中转发事件的类。 我想知道是否有办法做 它需要更少的代码开销。

这是我到目前为止所拥有的一个例子。

class A
{
   public event EventType EventA;
}

class B
{
   A m_A = new A();
   public event EventType EventB;

   public B()
   {
      m_A.EventA += OnEventA;
   }

   public void OnEventA()
   {
      if( EventB )
      {
         EventB();
      }
   }
}

A 类引发原始事件。 B 类将其作为 EventB 转发（本质上是同一事件）。 A 类对其他模块是隐藏的，因此它们无法直接订阅 EventA。

我想做的是减少 B 类中用于转发事件的代码开销，因为通常 B 类中没有真正处理事件。此外，我还将有几个不同的事件，因此需要编写大量 OnEvent B 类中的 () 方法仅用于转发事件。

是否可以以某种方式自动将 EventA 链接到 EventB，所以我会有这样的内容：

class B
{
   A m_A = new A();
   public event EventType EventB;

   public B()
   {
      m_A.EventA += EventB; // EventA automatically raises EventB.
   }
}

顺便说一句，我正在使用 C# 2.0 编译器。

Answer 1

绝对：

class B
{
    private A m_a = new A();

    public event EventType EventB
    {
        add { m_a.EventA += value; }
        remove { m_a.EventA -= value; }
    }
}

换句话说，Eve​​ntB 订阅/取消订阅代码只是将订阅/取消订阅请求传递给 EventA。

但请注意，这不允许您仅为订阅了 EventB 的订阅者引发事件。 这就像将某人的地址直接传递给大众营销公司，而您原来的方式更像是自己订阅大众营销公司，并允许人们要求您将邮件副本发送给他们。

Answer 2

IMO，您的原始代码（或多或少）是正确的。 特别是，它允许您提供正确的 sender（对于那些认为自己正在订阅 B 上的事件的人来说，这应该是 B 实例） >）。

如果未订阅事件，有一些技巧可以减少运行时的开销，但这会添加更多代码：

class B {
   A m_A = new A();
   private EventType eventB;
   public event EventType EventB {
       add { // only subscribe when we have a subscriber ourselves
           bool first = eventB == null;
           eventB += value;
           if(first && eventB != null) m_A.EventA += OnEventB;
       }
       remove { // unsubscribe if we have no more subscribers
           eventB -= value;
           if(eventB == null) m_A.EventA -= OnEventB;
       }
   }

   protected void OnEventB(object sender, EventArgsType args) {
      eventB?.Invoke(this, args); // note "this", not "sender"

   }
}

Answer 3

这就是我的想法：

public interface IExampleConnection
{
    event ReceivedDataEventHandler ReceivedData;
}

public class ConnectionProxy: IExampleConnection
{
    private IExampleConnection _innerConnection;

    // dictionary to store the original event handler and the closure around it with our own handling logic
    private IDictionary<ReceivedDataEventHandler, ReceivedDataEventHandler> _receivedData = new Dictionary<ReceivedDataEventHandler, ReceivedDataEventHandler>();

    // helps protect access to the dictionary containing the event handlers 
    private object objectLock = new object();

    public ConnectionProxy(IExampleConnection innerConnection)
    {
        _innerConnection = innerConnection;
    }
    
    public event ReceivedDataEventHandler ReceivedData
    {
        add
        {
            lock (objectLock)
            {
                // use the original event handler `value` as a key in the dictionary
                // our custom handler becomes the value
                _receivedData.Add(value, (sender, args) =>
                {
                    // insert logic that you want to run before the original event handler

                    // call the original event handler
                    value(sender, args);

                    // insert logic that you want to run after the original event handler finishes

                });
                // add our handler to the dictionary by using the value as the key
                _innerConnection.ReceivedData += _receivedData[value];
            }
        }
        remove
        {
            lock (objectLock)
            {
                // use the incoming event handler `value` to lookup our wrapper around it
                _innerConnection.ReceivedData -= _receivedData[value];
            }
        }
    }
}

这比我通常想要的代码要多一些。 我怀疑有办法让它更简洁，但它对于我的目的来说已经足够好了。