C# in Depth

Delegates35FINDING AN APPROPRIATE METHOD FOR THE DELEGATE INSTANCE’S ACTIONIn .NET, delegate instances always refer to methods. Our next ingredient is to find (orwrite, of course) a method that does what we want and has the same signature as the delegatetype we’re using. The idea is to make sure that when we try to invoke a delegateinstance, the parameters we use will all match up and we’ll be able to use the return value(if any) in the way we expect—just like a normal method call.Now consider these five method signatures as candidates to be used for a String-Processor instance:void PrintString (string x)void PrintInteger (int x)void PrintTwoStrings (string x, string y)int GetStringLength (string x)void PrintObject (object x)The first method has everything right, so we can use it to create a delegate instance.The second method takes one parameter, but it’s not string, so it’s incompatible withStringProcessor. The third method has the correct first parameter type, but it hasanother parameter as well, so it’s still incompatible.The fourth method has the right parameter list but a nonvoid return type. (If ourdelegate type had a return type, the return type of the method would have to matchthat too.) The fifth method is interesting—any time we invoke a StringProcessorinstance we could call the PrintObject method with the same arguments, becausestring derives from object. It would make sense to be able to use it for an instance ofStringProcessor, but C# 1 limits the delegate to have exactly the same parametertypes. 1 C# 2 changes this situation—see chapter 5 for more details. In some ways thefourth method is similar, as you could always ignore the unwanted return value. However,void and nonvoid return types are currently always deemed to be incompatible.Let’s assume we’ve got a method body for the compatible signature (PrintString)and move on to our next ingredient—the delegate instance itself.CREATING A DELEGATE INSTANCENow that we’ve got a delegate type and a method with the right signature, we can createan instance of that delegate type, specifying that this method be executed when the delegateinstance is invoked. There’s no good official terminology defined for this, but forthis book I will call it the action of the delegate instance. The exact form of the expressionused to create the delegate instance depends on whether the action uses an instancemethod or a static method. Suppose PrintString is a static method in a type calledStaticMethods and an instance method in a type called InstanceMethods. Here are twoexamples of creating an instance of StringProcessor:StringProcessor proc1, proc2;proc1 = new StringProcessor(StaticMethods.PrintString);InstanceMethods instance = new InstanceMethods();proc2 = new StringProcessor(instance.PrintString);1As well as the parameter types, you have to match whether the parameter is in (the default), out, or ref. It’sreasonably rare to use out/ref parameters with delegates, though.Licensed to Rhona Hadida