Forwarding events in C#

Question

I'm using a class that forwards events in C#. I was wondering if there's a way of doing it that requires less code overhead.

Here's an example of what I have so far.

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();
      }
   }
}

Class A raises the original event. Class B forwards it as EventB (which is essentially the same event). Class A is hidden from other modules so they can't subscribe to EventA directly.

What I'm trying to do is reduce the code overhead in class B for forwarding the event, as typically there's no real handling of the events in class B. Also I'll have several different events so it would require writing a lot of OnEvent() methods in class B that only serve to forward the events.

Is it possible to automatically link EventA to EventB in some way, so I'd have something like this:

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

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

I'm using a C# 2.0 compiler btw.

Great question, especially since you shouldn't forget to unsubscribe from EventA, otherwise there could be a memory leak (your object B will remain in memory as long as A is, even if it's no longer needed). — dbkk, Jun 30 '09 at 21:01

score 104 · Accepted Answer · edited Jun 30 '09 at 19:01

104

Absolutely:

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

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

In other words, the EventB subscription/unsubscription code just passes the subscription/unsubscription requests on to EventA.

Note that this doesn't allow you to raise the event just for subscribers who subscribed to EventB, however. It's like passing someone's address directly onto a mass marketing company, whereas your original way is more like subscribing to the mass marketing company yourself, and allowing people to ask you to send copies of the mails to them.

edited Jun 30 '09 at 19:01

Fredrik Mörk

155,851
29
291
343

answered Jun 30 '09 at 18:56

Jon Skeet

1,421,763
867
9,128
9,194

19

It does mean that a subscriber to `B.EventB` gets the wrong sender (`A` instead of `B`), though - which can be important... – Marc Gravell Jun 30 '09 at 20:22
9

True, true... depending on what you view as "wrong" of course. Probably worth documenting at least. – Jon Skeet Jun 30 '09 at 20:29
if you don't care about the sender then this pattern is very smooth imo – anion Feb 15 '21 at 19:57

Marc Gravell · Answer 2 · 2018-04-16T12:26:59.947

IMO, your original code is (more or less) correct. In particular, it allows you to provide the correct sender (which should be the B instance for people who think they are subscribing to an event on B).

There are some tricks to reduce the overheads at runtime if the event isn't subscribed, but this adds more code:

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"

   }
}

score 0 · Answer 3 · answered Nov 23 '21 at 14:02

This is what I came up with:

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];
            }
        }
    }
}

It's a bit more code than I would normally like. I suspect there's way to make it more concise, but it worked well enough for my purposes.

Forwarding events in C#

3 Answers3

Linked