+= operator with Events

Question

public void Bar()
{
    Foo foo = new Foo();
    **foo.MyEvent += foo_MyEvent;**
    foo.FireEvent();        
}

void foo_MyEvent(object sender, EventArgs e)
{
    ((Foo)sender).MyEvent -= foo_MyEvent;
}

Hey I'm a bit unfamiliar with events, could someone tell me what the += operator does with events?

Answer 1

+= subscribes to an event. The delegate or method on the right-hand side of the += will be added to an internal list that the event keeps track of, and when the owning class fires that event, all the delegates in the list will be called.

Answer 2

The answer you have accepted is a nice simplified version of what += does, but it's not the full story.

The += operator calls the add method on the event. Similarly -= calls remove. This usually results in the delegate being added to the internal list of handlers which are called when the event is fired, but not always.

It is perfectly possible to define add to do something else. This example may help to demonstrate what happens when you call +=:

class Test
{
    public event EventHandler MyEvent
    {
        add
        {
            Console.WriteLine("add operation");
        }

        remove
        {
            Console.WriteLine("remove operation");
        }
    }       

    static void Main()
    {
        Test t = new Test();

        t.MyEvent += new EventHandler (t.DoNothing);
        t.MyEvent -= null;
    }

    void DoNothing (object sender, EventArgs e)
    {
    }
} 

Output:

add operation
remove operation

See Jon Skeet's article on events and delegates for more information.

Answer 3

One of the great features of delegates is that you can combine them together. This is called multicasting. You can use the + or += operator to add another method to the invocation list of an existing delegate instance. Similarly, you can also remove a method from an invocation list by using the decrement assignment operator (- or -=). This feature forms the base for events in C#. Below is a multicast delegate example.

class Program
{
    static void Hello(string s)
    {
        Console.WriteLine("  Hello, {0}!", s);
    }

    static void Goodbye(string s)
    {
        Console.WriteLine("  Goodbye, {0}!", s);
    }

    delegate void Del(string s);

    static void Main()
    {
        Del a, b, c, d;

        // Create the delegate object a that references 
        // the method Hello:
        a = Hello;

        // Create the delegate object b that references 
        // the method Goodbye:
        b = Goodbye;

        // The two delegates, a and b, are composed to form c: 
        c = a + b;

        // Remove a from the composed delegate, leaving d, 
        // which calls only the method Goodbye:
        d = c - a;

        Console.WriteLine("Invoking delegate a:");
        a("A");
        Console.WriteLine("Invoking delegate b:");
        b("B");
        Console.WriteLine("Invoking delegate c:");
        c("C");
        Console.WriteLine("Invoking delegate d:");
        d("D");


        /* Output:
        Invoking delegate a:
          Hello, A!
        Invoking delegate b:
          Goodbye, B!
        Invoking delegate c:
          Hello, C!
          Goodbye, C!
        Invoking delegate d:
          Goodbye, D!
        */

        Console.ReadLine();
    }
}

All this is possible because delegates inherit from the System.MulticastDelegate class that in turn inherits from System.Delegate. Because of this, you can use the members that are defined in those base classes on your delegates. You can learn more about this in the article Delegates and Events in C# .NET

Answer 4

In this case method foo_MyEvent will fire whene that event is called (so you subscribe to the event in line 4)

Answer 5

Event is just the immutable list of delegates (i.e. subscribes which will get called when something publishes/invokes that event). You could argue that we could have used List instead. If we went that way, someone could have tempered with our subscribers.

In above scenario where you use List, you could do:

lstDelegate = newDelegate

and you have wiped existing subscribers (lstDelegate only contains ur delegate callback now).

To stop that behaivour we have Event. When you use event, complier wont allow you do that, you are only allowed to add/remove your own delegate by using += and -=. That's how I try to differentiate it anyway. hope it helps.

Answer 6

It add's handler to an event. It means that method on the right side of the operator will be invoked when the event will be risen.