1. Programming in C# CHAPTER - 8

2. 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

3. 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

4. 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));

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

6. 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.

7. 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); }

8. 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.

9. 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) …"

10. .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);

11. .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;