C# in Depth

140 CHAPTER 5 Fast-tracked delegates5.2 Method group conversionsIn C# 1, if you want to create a delegate instance you need to specify both the delegatetype and the action. If you remember from chapter 2, we defined the action to be themethod to call and (for instance methods) the target to call it on. So for example, in listing5.1 when we needed to create a KeyPressEventHandler we used this expression:new KeyPressEventHandler(LogKeyEvent)As a stand-alone expression, it doesn’t look too bad. Even used in a simple event subscriptionit’s tolerable. It becomes a bit uglier when used as part of a longer expression.A common example of this is starting a new thread:Thread t = new Thread (new ThreadStart(MyMethod));What we want to do is start a new thread that will execute MyMethod as simply as possible.C# 2 allows you to do this by means of an implicit conversion from a method groupto a compatible delegate type. A method group is simply the name of a method,optionally with a target—exactly the same kind of expression as we used in C# 1 to createdelegate instances, in other words. (Indeed, the expression was called a methodgroup back then—it’s just that the conversion wasn’t available.) If the method isgeneric, the method group may also specify type arguments. The new implicit conversionallows us to turn our event subscription intobutton.KeyPress += LogKeyEvent;Likewise the thread creation code becomes simplyThread t = new Thread (MyMethod);The readability differences between the original and the “streamlined” versions aren’thuge for a single line, but in the context of a significant amount of code, they canreduce the clutter considerably. To make it look less like magic, let’s take a brief lookat what this conversion is doing.First, let’s consider the expressions LogKeyEvent and MyMethod as they appear inthe examples. The reason they’re classified as method groups is that more than onemethod may be available, due to overloading. The implicit conversions available willconvert a method group to any delegate type with a compatible signature. So, if youhad two method signatures as follows:void MyMethod()void MyMethod(object sender, EventArgs e)you could use MyMethod as the method group in an assignment to either a ThreadStartor an EventHandler as follows:ThreadStart x = MyMethod;EventHandler y = MyMethod;However, you couldn’t use it as the parameter to a method that itself was overloaded totake either a ThreadStart or an EventHandler—the compiler would complain thatthe conversion was ambiguous. Likewise, you unfortunately can’t use an implicitLicensed to Rhona Hadida