C# in Depth

252 CHAPTER 9 Lambda expressions and expression treesWhen there are multiple parameters, the compiler has to make sure there isexactly one method that is at least as good as all the others for every parameter. As asimple example, suppose we hadvoid Write(int x, double y)void Write(double x, int y)A call to Write(1, 1) would be ambiguous, and the compiler would force you to add acast to at least one of the parameters to make it clear which method you meant to call.That logic still applies to C# 3, but with one extra rule about anonymous functions,which never specify a return type. In this case, the inferred return type (as describedin 9.4.2) is used in the “better conversion” rules.Let’s see an example of the kind of situation that needs the new rule. Listing 9.16contains two methods with the name Execute, and a call using a lambda expression.Listing 9.16Sample of overloading choice influenced by delegate return typestatic void Execute(Func action){Console.WriteLine("action returns an int: "+action());}static void Execute(Func action){Console.WriteLine("action returns a double: "+action());}...Execute( () => 1 );The call to Execute in listing 9.16 could have been written with an anonymous methodor a method group instead—the same rules are applied whatever kind of conversion isinvolved. So, which Execute method should be called? The overloading rules say thatwhen two methods are both applicable after performing conversions on the arguments,then those argument conversions are examined to see which one is “better.” The conversionshere aren’t from a normal .NET type to the parameter type—they’re from alambda expression to two different delegate types. So, which conversion is better?Surprisingly enough, the same situation in C# 2 would result in a compilationerror—there was no language rule covering this case. In C# 3, however, the methodwith the Func parameter would be chosen. The extra rule that has been addedcan be paraphrased to this:If an anonymous function can be converted to two delegate types that havethe same parameter list but different return types, then the delegateconversions are judged by the conversions from the inferred return type tothe delegates’ return types.That’s pretty much gibberish without referring to an example. Let’s look back at listing9.16: we’re converting from a lambda expression with no parameters and aninferred return type of int to either Func or Func. The parameter listsare the same (empty) for both delegate types, so the rule applies. We then just need toLicensed to Rhona Hadida