C# in Depth

Covariance and contravariance141method group conversion to convert to the plain System.Delegate type since thecompiler doesn’t know which specific delegate type to create an instance of. This is abit of a pain, but you can still be slightly briefer than in C# 1 by making the conversionexplicit. For example:Delegate invalid = SomeMethod;Delegate valid = (ThreadStart)SomeMethod;As with generics, the precise rules of conversion are slightly complicated, and the “justtry it” rule works very well: if the compiler complains that it doesn’t have enoughinformation, just tell it what conversion to use and all should be well. If it doesn’t complain,you should be fine. For the exact details, consult the language specification.Speaking of possible conversions, there may be more than you expect, as we’ll see inour next section.5.3 Covariance and contravarianceWe’ve already talked quite a lot about the concepts of covariance and contravariancein different contexts, usually bemoaning their absence, but delegate constructionis the one area in which they are actually available in C#. If you want to refreshyourself about the meaning of the terms at a relatively detailed level, refer back tosection 2.3.2—but the gist of the topic with respect to delegates is that if it would bevalid (in a static typing sense) to call a method and use its return value everywherethat you could invoke an instance of a particular delegate type and use its returnvalue, then that method can be used to create an instance of that delegate type.That’s all pretty wordy, but it’s a lot simpler with examples.Let’s consider the event handlers we’ve got in our little Windows Forms application.The signatures 1 of the three delegate types involved are as follows:void EventHandler (object sender, EventArgs e)void KeyPressEventHandler (object sender, KeyPressEventArgs e)void MouseEventHandler (object sender, MouseEventArgs e)Now, consider that KeyPressEventArgs and MouseEventArgs both derive from Event-Args (as do a lot of other types—at the time of this writing, MSDN lists 386 types thatderive directly from EventArgs). So, if you have a method that takes an EventArgsparameter, you could always call it with a KeyPressEventArgs argument instead. Ittherefore makes sense to be able to use a method with the same signature asEventHandler to create an instance of KeyPressEventHandler—and that’s exactly whatC# 2 does. This is an example of contravariance of parameter types.To see that in action, let’s think back to listing 5.1 and suppose that we don’t needto know which event was firing—we just want to write out the fact that an event hashappened. Using method group conversions and contravariance, our code becomesquite a lot simpler, as shown in listing 5.2.1I’ve removed the public delegate part for reasons of space.Licensed to Rhona Hadida