# 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 Button 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 Button click. Here is the sequence of events that occurs:
* User presses the mouse button down over a button
** The .NET framework raises a MouseDown event
* User releases the mouse button
** The .NET framework raises a MouseUp event
** The .NET framework raises a MouseClick event
** The .NET framework raises a Clicked event on the Button
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 delegate voidProcedure. This statement is a complete abstraction. It does not result in executable code that does any work, but merely declares a delegate type called Procedure that takes no arguments and returns nothing. Next, in the Main method, the statement Procedure someProcs = null; instantiates a delegate. The assignment means that the delegate is not initially referencing any methods. The statements someProcs += newProcedure(DelegateDemo.Method1) and someProcs += newProcedure(Method2) add two static methods to the delegate instance. Note that the class name can also be left off, as the statement is occurring inside DelegateDemo. The statement someProcs += newProcedure(demo.Method3) 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, Method3 is called on the object that was supplied when the method was added to the delegate instance. Finally, the statement someProcs 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 NullReferenceException.
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 delegate 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:

### Lambda expressions

Lambda expressions are a clearer way to achieve the same thing as an anonymous delegate. Its form is:
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, str is a string, and the return type is an int:
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.