[Note: Event declarations typically omit event-accessor-declarations, as in
the Button example above. One
situation for doing so involves the case in which the storage cost of one
field per event is not acceptable. In such
cases, a class can include event-accessor-declarations and use a private
mechanism for storing the list of event
handlers. Similarly, in cases where the handling of an event requires
access to external resources, event accessors
may be used to manage these resources. end note]
The event-accessor-declarations of an event specify the executable
statements associated with adding and
removing event handlers.
The accessor declarations consist of an add-accessor-declaration and a
remove-accessor-declaration. Each
accessor declaration consists of the token add or remove followed by a
block. The block associated with an addaccessor-
declaration specifies the statements to execute when an event handler is
added, and the block associated
with a remove-accessor-declaration specifies the statements to execute when
an event handler is removed.
Each add-accessor-declaration and remove-accessor-declaration corresponds
to a method with a single value
parameter of the event type, and a void return type. The implicit parameter
of an event accessor is named
value. When an event is used in an event assignment, the appropriate event
accessor is used. Specifically, if the
assignment operator is += then the add accessor is used, and if the
assignment operator is ?= then the remove
accessor is used. In either case, the right-hand operand of the assignment
operator is used as the argument to the
event accessor. The block of an add-accessor-declaration or a
remove-accessor-declaration must conform to the
rules for void methods described in §17.5.8. In particular, return
statements in such a block are not permitted
to specify an expression.
Since an event accessor implicitly has a parameter named value, it is a
compile-time error for a local variable or
constant declared in an event accessor to have that name.
C# LANGUAGE SPECIFICATION
250
[Example: In the example
class Control: Component
{
// Unique keys for events
static readonly object mouseDownEventKey = new object();
static readonly object mouseUpEventKey = new object();
// Return event handler associated with key
protected Delegate GetEventHandler(object key) {?}
// Add event handler associated with key
protected void AddEventHandler(object key, Delegate handler) {?}
// Remove event handler associated with key
protected void RemoveEventHandler(object key, Delegate handler) {?}
// MouseDown event
public event MouseEventHandler MouseDown {
add { AddEventHandler(mouseDownEventKey, value); }
remove { RemoveEventHandler(mouseDownEventKey, value); }
}
// MouseUp event
public event MouseEventHandler MouseUp {
add { AddEventHandler(mouseUpEventKey, value); }
remove { RemoveEventHandler(mouseUpEventKey, value); }
}
// Invoke the MouseUp event
protected void OnMouseUp(MouseEventArgs args) {
MouseEventHandler handler;
handler = (MouseEventHandler)GetEventHandler(mouseUpEventKey);
if (handler != null)
handler(this, args);
}
}
the Control class implements an internal storage mechanism for events. The
AddEventHandler method
associates a delegate value with a key, the GetEventHandler method returns
the delegate currently associated
with a key, and the RemoveEventHandler method removes a delegate as an
event handler for the specified
event. Presumably, the underlying storage mechanism is designed such that
there is no cost for associating a
null delegate value with a key, and thus unhandled events consume no
storage. end example]