8.7.5 Events
An event is a member that enables an object or class to provide
notifications. A class defines an event by
providing an event declaration (which resembles a field declaration, though
with an added event keyword)
and an optional set of event accessors. The type of this declaration must
be a delegate type.
An instance of a delegate type encapsulates one or more callable entities.
For instance methods, a callable
entity consists of an instance and a method on that instance. For static
methods, a callable entity consists of
just a method. Given a delegate instance and an appropriate set of
arguments, one can invoke all of that
delegate instance.s methods with that set of arguments.
In the example
public delegate void EventHandler(object sender, System.EventArgs e);
public class Button
{
public event EventHandler Click;
public void Reset() {
Click = null;
}
}
the Button class defines a Click event of type EventHandler. Inside the
Button class, the Click
member is exactly like a private field of type EventHandler. However,
outside the Button class, the
Click member can only be used on the left-hand side of the += and .=
operators. The += operator adds a
handler for the event, and the -= operator removes a handler for the event.
The example
using System;
public class Form1
{
public Form1() {
// Add Button1_Click as an event handler for Button1.s Click event
Button1.Click += new EventHandler(Button1_Click);
}
Button Button1 = new Button();
void Button1_Click(object sender, EventArgs e) {
Console.WriteLine("Button1 was clicked!");
}
public void Disconnect() {
Button1.Click -= new EventHandler(Button1_Click);
}
}
shows a Form1 class that adds Button1_Click as an event handler for
Button1.s Click event. In the
Disconnect method, that event handler is removed.
For a simple event declaration such as
public event EventHandler Click;
the compiler automatically provides the implementation underlying the +=
and -= operators.
An implementer who wants more control can get it by explicitly providing
add and remove accessors. For
example, the Button class could be rewritten as follows:
public class Button
{
private EventHandler handler;
public event EventHandler Click {
add { handler += value; }
Chapter 8 Language Overview
37
remove { handler -= value; }
}
}
This change has no effect on client code, but allows the Button class more
implementation flexibility. For
example, the event handler for Click need not be represented by a field.