C Sharp Programming/Delegates and Events

Introduction
Delegates and events are fundamental to any Windows or Web Application, allowing the developer to "subscribe" to particular actions carried out by the user. Therefore, instead of expecting everything and filtering out what you want, you choose what you want to be notified of and react to that action.

A delegate is a way of telling C# which method to call when an event is triggered. For example, if you click a on a form, the program would call a specific method. It is this pointer that is a delegate. Delegates are good, as you can notify several methods that an event has occurred, if you wish so.

An event is a notification by the .NET framework that an action has occurred. Each event contains information about the specific event, e.g., a mouse click would say which mouse button was clicked where on the form.

Let's say you write a program reacting only to a click. Here is the sequence of events that occurs:


 * User presses the mouse button down over a button
 * The .NET framework raises a event
 * User releases the mouse button
 * The .NET framework raises a event
 * The .NET framework raises a event
 * The .NET framework raises a event on the

Since the button's click event has been subscribed, the rest of the events are ignored by the program and your delegate tells the .NET framework which method to call, now that the event has been raised.

Delegates
Delegates form the basis of event handling in C#. They are a construct for abstracting and creating objects that reference methods and can be used to call those methods. A delegate declaration specifies a particular method signature. References to one or more methods can be added to a delegate instance. The delegate instance can then be "called", which effectively calls all the methods that have been added to the delegate instance. A simple example:

In this example, the delegate is declared by the line. This statement is a complete abstraction. It does not result in executable code that does any work, but merely declares a delegate type called that takes no arguments and returns nothing. Next, in the method, the statement  = ; instantiates a delegate. The assignment means that the delegate is not initially referencing any methods. The statements +=  and += add two static methods to the delegate instance. Note that the class name can also be left off, as the statement is occurring inside. The statement +=  adds a non-static method to the delegate instance. For a non-static method, the method name is preceded by an object reference. When the delegate instance is called, is called on the object that was supplied when the method was added to the delegate instance. Finally, the statement calls the delegate instance. All the methods that were added to the delegate instance are now called in the order that they were added.

Methods that have been added to a delegate instance can be removed with the  operator:

In C# 2.0, adding or removing a method reference to a delegate instance can be shortened as follows:

Invoking a delegate instance that presently contains no method references results in a.

Note that, if a delegate declaration specifies a return type and multiple methods are added to a delegate instance, an invocation of the delegate instance returns the return value of the last method referenced. The return values of the other methods cannot be retrieved (unless explicitly stored somewhere in addition to being returned).

Anonymous delegates
Anonymous delegates are a short way to write delegate code, specified using the keyword. The delegate code can also reference local variables of the function in which they are declared. Anonymous delegates are automatically converted into methods by the compiler. For example:

They can accept arguments just as normal methods can:

The output is:

testing testing, 100

Lambda expressions
Lambda expressions are a clearer way to achieve the same thing as an anonymous delegate. Its form is:

(type1 arg1, type2 arg2, ...) => expression

This is equivalent to:

If there is only one argument, the parentheses can be omitted. The type names can also be omitted to let the compiler infer the types from the context. In the following example, is a, and the return type is an :

This is equivalent to:

Events
An event is a special kind of delegate that facilitates event-driven programming. Events are class members that cannot be called outside of the class regardless of its access specifier. So, for example, an event declared to be public would allow other classes the use of  and   on the event, but firing the event (i.e. invoking the delegate) is only allowed in the class containing the event. A simple example:

A method in another class can then subscribe to the event by adding one of its methods to the event delegate:

Even though the event is declared public, it cannot be directly fired anywhere except in the class containing it.