What are the effects of adding EventHandler += EventHandler?

Question

I have a SelectionChanged event in class A that I want to relay through class B. I assumed that declaring a SelectionChanged event in class B and assigning this EventHandler to A.SelectionChanged would cause B.SelectionChanged to trigger whenever A.SelectionChanged was triggered - this turned out to be false.

To be more clear, some code:

class A
{
   public event EventHandler SelectionChanged;

   public void TriggerSelectionChanged()
   {
      if (SelectionChanged != null) SelectionChanged(this, EventArgs.Empty);
   }
}

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

   public A A { get { return _a; } }

   public event EventHandler SelectionChanged;

   public B()
   {
      A.SelectionChanged += SelectionChanged;
   }

   public static void Test()
   {
      B relayer = new B();
      bool wasRelayed = false;
      relayer.SelectionChanged += delegate { wasRelayed = true; };
      relayer.A.TriggerSelectionChanged();

      System.Console.WriteLine("Relayed: {0}", wasRelayed);
   }
}

This prints out "Relayed: false".

What are the effects of adding an EventHandler to another EventHandler?

EDIT: Note! I'm aware of that a solution to this is to relay the event through an delegate, function etc etc, but I'm mostly interrested in knowning what the effects of this code is.

score 2 · Answer 1 · edited May 23 '17 at 12:19

2

There is nothing in your code that 'connects' the invocation of B.SelectionChanged to A.SelectionChanged. Therefore, when you fire a SelectionChanged on A, your delegate that handles SelectionChanged on B is not invoked.

I think what you want is for your event on B to acts as an adapter on the event that A exposes? If this is the case, you will need to write your own add / remove logic. See the following:

Events + Adapter Pattern

Another example of add / remove:

C#: event with explicity add/remove != typical event?

edited May 23 '17 at 12:19

Community

1
1

answered Jul 08 '11 at 10:16

ColinE

68,894
15
164
232

I forgot to add the constructor connecting B to A, edited the question. – larsmoa Jul 08 '11 at 10:19

Ian · Answer 2 · 2011-07-08T10:26:02.200

In this case B's SelectionChanged and A's SelectionChanged are not related.

If you were to make B inherit from A and remove the second declaration on B then this would work.

class A
{
   public EventHandler SelectionChanged;

   public void TriggerSelectionChanged()
   {
      if (SelectionChanged != null) SelectionChanged(this, EventArgs.Empty);
   }
}

class B : A
{
   public static void Test()
   {
      B relayer = new B();
      bool wasRelayed = false;
      relayer.SelectionChanged += delegate { wasRelayed = true; };
      relayer.TriggerSelectionChanged();

      System.Console.WriteLine("Relayed: {0}", wasRelayed);
   }
}

Or you can pump your messages through...

class A
{
   public EventHandler SelectionChanged;

   public void TriggerSelectionChanged()
   {
      if (SelectionChanged != null) SelectionChanged(this, EventArgs.Empty);
   }
}

class B
{
   public B()
   {
     this._a.SelectionChanged += (o, s) => 
     {
       if(this.SelectionChanged != null) { this.SelectionChange(o, s); }
     };
   }




private A _a = new A();

   public A A { get { return _a; } }

   public EventHandler SelectionChanged;

   public static void Test()
   {
      B relayer = new B();
      bool wasRelayed = false;
      relayer.SelectionChanged += delegate { wasRelayed = true; };
      relayer.A.TriggerSelectionChanged();
      System.Console.WriteLine("Relayed: {0}", wasRelayed);
   }

}

@larsm, I've added similar code to do what you're trying. I don't think you can do what you're trying in your modified code, think it needs to be a delegate. — Ian, Jul 08 '11 at 10:25
@Ian: that's my fallback. However, I'm mostly interrested in the effects of EventHandler += EventHandler, not the other solutions. — larsmoa, Jul 08 '11 at 10:27

score 1 · Accepted Answer · answered Jul 08 '11 at 11:06

It turns out that this is an effect from EventHandler being a Delegate. This class implements operator += through (or so I assume) using Delegate.Combine. The documentation of this function reads

Concatenates the invocation lists of the specified multicast (combinable) delegates.

What happens is that all handlers assigned to the EventHandler on the right side are added to the EventHandler on the left. In this case there's zero handlers so nothing happens. However, if the order of things are changed such that B.SelectionChanged is assigned before B.SelectionChanged is connected to A.SelectionChanged things are hooked up correctly. However, removing an handler from B does not remove it from A so doing this should be highly frawned upon.

What are the effects of adding EventHandler += EventHandler?

3 Answers3