C# 5.0 Programmer's Reference

292 ❘ CHAPTER 12 Classes and Structures
Raising Events
To raise an event, the code must first determine whether any other pieces of code have registered to
catch the event. It does that by comparing the event to null. (This is a fairly odd syntax but that’s
the way C# does it.)
If the event handler isn’t null, the code “invokes” it, passing it any required parameters. The program
then invokes each of the registered event handlers in turn, passing them those parameters.
For example, suppose the Student class defined a GradeChanged event. Then the following snippet
inside the Student class raises the event, passing it the current Student object as a parameter.
if (GradeChanged != null) GradeChanged(this);
Catching Events
To subscribe to an event, a program uses the += operator to “add” the event handler to the event.
For example, suppose the Person class defines a NameChanged event. Suppose the main program
creates an instance of the Person class named MyPerson. Finally, suppose the main program defines
an event handler named MyPerson_NameChanged to handle that event. Then the main program
could use the following code to subscribe to the event.
MyPerson.NameChanged += MyPerson_NameChanged;
If the program executes this code multiple times, then when the event is raised, the event handler will
be called multiple times.
To unsubscribe from an event, use the -= operator. The following code shows how a program might
unsubscribe from the Person class’s NameChanged event.
MyPerson.NameChanged -= MyPerson_NameChanged;
(This example is described further in the next section.)
1 – 2 = 0
A program can unsubscribe from an event more times than it subscribed to it without
causing any harm. For example, if the program uses += to subscribe to the event three
times and then uses -= to unsubscribe from it four times, nothing bad happens. The
program just doesn’t catch the event.
Using Event Delegate Types
The delegate part of the event declaration is a delegate type that defines the parameters that the
event handler takes when it catches the event. You can create your own delegate type, use a predefined
Action delegate type, or use the special EventHandler delegate type.
www.it-ebooks.info