C# Programming/Delegates and Events

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 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:

usingSystem;
delegatevoidProcedure();
classDelegateDemo
{
publicstaticvoidMethod1()
{
Console.WriteLine("Method 1");
}
publicstaticvoidMethod2()
{
Console.WriteLine("Method 2");
}
publicvoidMethod3()
{
Console.WriteLine("Method 3");
}
staticvoidMain()
{
ProceduresomeProcs=null;
someProcs+=newProcedure(DelegateDemo.Method1);
someProcs+=newProcedure(Method2);// Example with omitted class name
DelegateDemodemo=newDelegateDemo();
someProcs+=newProcedure(demo.Method3);
someProcs();
}
}

In this example, the delegate is declared by the line delegate void Procedure(). 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 ProceduresomeProcs = null ; instantiates a delegate. The assignment means that the delegate is not initially referencing any methods. The statements someProcs += new Procedure(DelegateDemo.Method1) and someProcs += new Procedure(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 += new Procedure(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:

someProcs-=newProcedure(DelegateDemo.Method1);

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

someProcs+=DelegateDemo.Method1;
someProcs-=DelegateDemo.Method1;

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 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:

usingSystem;
delegatevoidProcedure();
classDelegateDemo2
{
staticProceduresomeProcs=null;
privatestaticvoidAddProc()
{
intvariable=100;

someProcs+=newProcedure(delegate
{
Console.WriteLine(variable);
});
}
staticvoidMain()
{
someProcs+=newProcedure(delegate{Console.WriteLine("test");});
AddProc();
someProcs();
Console.ReadKey();
}
}

They can accept arguments just as normal methods can:

usingSystem;
delegatevoidProcedure(stringtext);
classDelegateDemo3
{
staticProceduresomeProcs=null;

privatestaticvoidAddProc()
{
intvariable=100;

someProcs+=newProcedure(delegate(stringtext)
{
Console.WriteLine(text+", "+variable.ToString());
});
}

staticvoidMain()
{
someProcs+=newProcedure(delegate(stringtext){Console.WriteLine(text);});
AddProc();
someProcs("testing");
Console.ReadKey();
}
}

The output is:

testing
testing, 100

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:

delegate(type1arg1,type2arg2,...)
{
returnexpression;
}

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 :

Func<string,int>myFunc=str=>int.Parse(str);

This is equivalent to:

Func<string,int>myFunc=delegate(stringstr)
{
returnint.Parse(str);
};

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:

publicdelegatevoidButtonClickedHandler();
classButton
{
publiceventButtonClickedHandlerButtonClicked;
ButtonClicked+=()=>{Console.WriteLine("click simulation !");};
publicvoidSimulateClick()
{
if(ButtonClicked!=null)
{
ButtonClicked();
}
}
...
}

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

Buttonb=newButton();
b.ButtonClicked+=ButtonClickHandler;
privatevoidButtonClickHandler()
{
//Handle the event
}

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

• Book:C Sharp Programming