C# in Depth

Delegates41Likewise, when you subscribe to or unsubscribe from an event, it looks like you’reusing a field whose type is a delegate type, with the += and -= operators. Again,though, you’re actually calling methods (add and remove 5 ). That’s all you can do witha pure event—subscribe to it (add an event handler) or unsubscribe from it (removean event handler). It’s up to the event methods to do something useful—such as takingnotice of the event handlers you’re trying to add and remove, and making themavailable elsewhere within the class.The reason for having events in the first place is very much like the reason forhaving properties—they add a layer of encapsulation. Just as you don’t want othercode to be able to set field values without the owner at least having the option of validatingthe new value, you often don’t want code outside a class to be able to arbitrarilychange (or call) the handlers for an event. Of course, a class can add methodsto give extra access—for instance, to reset the list of handlers for an event, or toraise the event (in other words, call its event handlers). For example, Background-Worker.OnProgressChanged just calls the ProgressChanged event handlers. However,if you only expose the event itself, code outside the class only has the ability toadd and remove handlers.Field-like events make the implementation of all of this much simpler to look at—asingle declaration and you’re done. The compiler turns the declaration into both anevent with default add/remove implementations, and a private delegate type field.Code inside the class sees the field; code outside the class only sees the event. Thismakes it look as if you can invoke an event—but what you actually do to call the eventhandlers is invoke the delegate instance stored in the field.The details of events are outside the scope of this chapter—events themselves haven’tchanged significantly in C# 2 or 3—but I wanted to draw attention to the differencebetween delegate instances and events now, to prevent it causing confusion later on.2.1.4 Summary of delegatesSo, to summarize what we’ve covered on delegates:■■■■■■■Delegates allow behavior to be encapsulated.The declaration of a delegate type controls which methods can be used to createdelegate instances.Creating a delegate instance requires a method and (for instance methods) atarget to call the method on.Delegate instances are immutable.Delegate instances each contain an invocation list—a list of actions.Delegate instances can be combined together and removed from each other.Events are not delegate instances—they’re just add/remove method pairs(think property getters/setters).5These aren’t their names in the compiled code; otherwise you could only have one event per type. The compilercreates two methods with names that aren’t used elsewhere, and a special piece of metadata to let othertypes know that there’s an event with the given name, and what its add/remove methods are called.Licensed to Rhona Hadida