Delegates & Events 1

Delegates Delegates are how C# defines a dynamic interface between two methods Same goal as function pointers in C Delegates are type-safe A delegate object holds a reference to a method with a pre-defined signature A signature is simply the argument list and return type of the method The keyword delegate specifies that we are defining a delegate object

Delegates Consists of two parts: a delegate type and a delegate instance A delegate type looks like an (abstract) method declaration, preceded with the delegate keyword A delegate instance creates an instance of this type, supplying it with the name of a real method to attach to

Declaring a Delegate A Delegate Declaration Defines a Type That Encapsulates a Method with a Particular Set of Arguments and Return Type // declares a delegate for a method that takes a single // argument of type double and has a void return type delegate void MyDelegate(double d);

Instantiating a Delegate A Delegate Object Is Created with the new Operator Delegate Objects Are Immutable The method signature must match the delegate signature // instantiating a delegate to a static method Calculate // in the class MyClass MyDelegate a = new MyDelegate(MyClass.Calculate); // instantiating a delegate to an instance method // AMethod in object p MyClass p = new MyClass(); MyDelegate b = new MyDelegate(p.AMethod);

Calling a Delegate Use a Statement Containing: The name of the delegate object Followed by the parenthesized arguments to be passed to the delegate // given the previous delegate declaration and // instantiation, the following invokes MyClass' // static method Calculate with the parameter 0.123 a(0.123);

Chaining (Multicast) Delegate Delegate objects can be initialized with several method calls using the += operator The method calls can then be invoked in a chain by passing the correct arguments to the delegate object Essentially it amounts to calling methods through a proxy object and is a powerful mechanism for event handling as we shall see Passing method calls into objects is then equivalent to passing delegate objects

Chaining (Multicast) Delegate A delegate instance is actually a container of callback functions. It can hold a list of values. The operators += and -= are defined to add and remove values. The operator = clears the list and assigns it to the rhs

Declaring an Event Declare the Delegate Type for the Event Declare the Event Like the field of delegate type preceded by an event keyword // MouseClicked delegate declared public delegate void MouseClickedEventHandler(); public class Mouse { // MouseClicked event declared public static event MouseClickedEventHandler MouseClickedHandler; //... }

Connecting to an Event An application can then register its interest in an event by adding an initialized delegate object to the event using the += operator // Client’s method to handle the MouseClick event private void MouseClicked() { //... } //... // Client code to connect to MouseClicked event Mouse.MouseClickedHandler += new MouseClickedEventHandler(MouseClicked); // Client code to break connection to MouseClick event Mouse.MouseClickedHandler -= new

Raising an Event Check Whether Any Clients Have Connected to This Event If the event field is null, there are no clients Raise the Event by Invoking the Event’s Delegate if (MouseClickedHandler != null) MouseClickedHandler();

.NET Framework Guidelines Name Events with a Verb and Use Pascal Casing Use "Raise" for Events, Instead of "Fire" Event Argument Classes Extend System.EventArgs Event Delegates Return Void and Have Two Arguments Use a Protected Virtual Method to Raise Each Event public class SwitchFlippedEventArgs : EventArgs { ... } public delegate void SwitchFlippedEventHandler( object sender, SwitchFlippedEventArgs e); public event SwitchFlippedEventHandler SwitchFlippedHandler;

When to Use Delegates, Events, and Interfaces Use a Delegate If: You basically want a C-style function pointer You want single callback invocation The callback should be registered in the call or at construction time, not through methods Use Events If: Client signs up for the callback function through methods More than one object will care Use an Interface If: The callback function entails complex behavior, such as multiple methods

Custom Event Example using System; namespace CustomEventExample { public delegate void ElapsedMinuteEventHandler(Object sender, MinuteEventArgs e); }

Custom Event Example using System; namespace CustomEventExample { public class MinuteEventArgs : EventArgs private DateTime date_time; public MinuteEventArgs(DateTime date_time) this.date_time = date_time; } public int Minute get { return date_time.Minute; }

Custom Event Example using System; namespace CustomEventExample { public class Publisher public event ElapsedMinuteEventHandler MinuteTick; public Publisher() { Console.WriteLine("Publisher Created"); } public void countMinutes() int current_minute = DateTime.Now.Minute; while (true) if (current_minute != DateTime.Now.Minute) Console.WriteLine("Publisher: {0}", DateTime.Now.Minute); onMinuteTick(new MinuteEventArgs(DateTime.Now)); current_minute = DateTime.Now.Minute; }//end if } // end countMinutes method public void onMinuteTick(MinuteEventArgs e) { if (MinuteTick != null) MinuteTick(this, e); } } // end Publisher class definition } // end CustomEventExample namespace

Custom Event Example using System; namespace CustomEventExample { public class Subscriber private Publisher publisher; public Subscriber(Publisher publisher) this.publisher = publisher; subscribeToPublisher(); Console.WriteLine("Subscriber Created"); } public void subscribeToPublisher() { publisher.MinuteTick += new ElapsedMinuteEventHandler(minuteTickHandler); } public void minuteTickHandler(Object sender, MinuteEventArgs e) { Console.WriteLine("Subscriber Handler Method: {0}", e.Minute); } } // end Subscriber class definition } // end CustomEventExample namespace

Custom Event Example using System; namespace CustomEventExample { public class MainApp public static void Main() Console.WriteLine("Custom Events are Cool!"); Publisher p = new Publisher(); Subscriber s = new Subscriber(p); p.countMinutes(); } // end main } //end MainApp class definition } // end CustomEventExample namespace

?

References