Programming in C# CHAPTER - 8

C# Delegates and Events A delegate in C# contains one or more method references: its invocation list. Invoking the delegate invokes the methods in its invocation list. Delegates are primarily used for event handling. delegate method invocation list

Basic delegate pattern in C# delegate void MyDelegate(int x); // declare a delegate type class Eater { static void EatAnInt(int x) {…} void ConsumeAnInt(int x) {…} // some methods for the invocation list static void Main() { Eater etr = new Eater(); MyDelegate d = new MyDelegate(EatAnInt) + new MyDelegate(etr.ConsumeAnInt); //create a delegate d(5); } //invoke it; both EatAnInt(x) and etr.ConsumeAnInt(x) will be invoked

Example from C# delegate // Declare a delegate type for processing a book: public delegate void ProcessBkDelegate(Book book); // Call a passed-in delegate on each book public void ProcessBooks(ProcessBkDelegate processBk) { foreach (Book b in list) { processBk(b); } } static void PrintTitle(Book b) {…} bookDB.ProcessBooks(new ProcessBkDelegate(PrintTitle)); PriceTotaller totaller = new PriceTotaller(); bookDB.ProcessBooks(new ProcessBkDelegate(totaller.AddBookToTotal));

Event Handling: Observer Pattern aSource aListener register eventInfo new notify(eventInfo) query

Event Handling Event source is a class-instance; listener is a method. Event source has a delegate member to store listeners. Keyword event is used to declare this member. Listener registers by adding itself to the delegate's invocation list. Event info is stored in an EventArgs object.

Example: C# Event Handling public delegate void FlashHandler(object sender,EventArgs e); class Thunderstorm { public event FlashHandler Lightning; } class Weatherman { static void CountFlashes(object sender, EventArgs e) {…} public static void Main() { Thunderstorm storm = new Thunderstorm(); storm.Lightning += new FlashHandler(CountFlashes); }

Semantics of the event keyword Differences between public event DelegateType FooEvent public DelegateType FooDelegate Event can be invoked only from inside the class: obj.FooEvent() is illegal! Even subclasses cannot directly invoke event! Outside the class, can only change invocation list: obj.FooEvent += new DelegateType(…); obj.FooEvent -= new DelegateType(…); Events can be declared in an interface.

Inheritance and C# events Since subclasses cannot invoke events, one often creates a method to invoke it: event ClickHandler Click; public OnClick() { if (Click!=null) Click(); } event ClickHandler Click; public virtual OnClick() { if (Click!=null) Click(); } This is also a good place to check that there are listeners: "if (Click != null) …"

.NET Framework Event Guidelines C# allows you to use any delegate type for event: delegate MyReturnType MyDelegateType(MyArgType); event MyDelegateType MyEvent; The .NET framework provides two system types: System.EventArgs (used for event info) System.EventHandler (delegate type) Signature of EventHandler: delegate void EventHandler(object sender,EventArgs e);

.NET Framework Event Guidelines In most cases, simply use EventHandler for your events: event EventHandler MyEvent; You pass in the source of the event as the sender, and you use Empty for the event args: MyEvent(this, EventArgs.Empty); If you need to pass more event info, you declare a subclass of EventArgs: class MyEventArgs:EventArgs {...} delegate void MyHandler(object src, MyEventArgs e); event MyHandler MyEvent;