Posts
208
Comments
1144
Trackbacks
51
C# 4 Named Parameters for Overload Resolution

C# 4 is getting a new feature called named parameters. Although this is a stand-alone feature, it is often used in conjunction with optional parameters. Last week when I was giving a presentation on C# 4, I got a question on a scenario regarding overload resolution that I had not considered before which yielded interesting results. Before I describe the scenario, a little background first.

Named parameters is a well documented feature that works like this: suppose you have a method defined like this:

   1:  void DoWork(int num, string message = "Hello")
   2:  {
   3:      Console.WriteLine("Inside DoWork() - num: {0}, message: {1}", num, message);
   4:  }

This enables you to call the method with any of these:

   1:  DoWork(21);
   2:  DoWork(num: 21);
   3:  DoWork(21, "abc");
   4:  DoWork(num: 21, message: "abc");

and the corresponding results will be:

Inside DoWork() - num: 21, message: Hello
Inside DoWork() - num: 21, message: Hello
Inside DoWork() - num: 21, message: abc
Inside DoWork() - num: 21, message: abc

This is all pretty straight forward and well-documented. What is slightly more interesting is how resolution is handled with method overloads. Suppose we had a second overload for DoWork() that looked like this:

   1:  void DoWork(object num)
   2:  {
   3:      Console.WriteLine("Inside second overload: " + num);
   4:  }

The first rule applied for method overload resolution in this case is that it looks for the most strongly-type match first.  Hence, since the second overload has System.Object as the parameter rather than Int32, this second overload will never be called for any of the 4 method calls above.  But suppose the method overload looked like this:

   1:  void DoWork(int num)
   2:  {
   3:      Console.WriteLine("Inside second overload: " + num);
   4:  }

In this case, both overloads have the first parameter as Int32 so they both fulfill the first rule equally.  In this case the overload with the optional parameters will be ignored if the parameters are not specified. Therefore, the same 4 method calls from above would result in:

Inside second overload: 21
Inside second overload: 21
Inside DoWork() - num: 21, message: abc
Inside DoWork() - num: 21, message: abc

Even all this is pretty well documented. However, we can now consider the very interesting scenario I was presented with. The question was what happens if you change the parameter name in one of the overloads.  For example, what happens if you change the parameter *name* for the second overload like this:

   1:  void DoWork(int num2)
   2:  {
   3:      Console.WriteLine("Inside second overload: " + num2);
   4:  }

In this case, the first 2 method calls will yield *different* results:

   1:  DoWork(21);
   2:  DoWork(num: 21);

results in:

Inside second overload: 21
Inside DoWork() - num: 21, message: Hello

We know the first method call will go to the second overload because of normal method overload resolution rules which ignore the optional parameters.  But for the second call, even though all the same rules apply, the compiler will allow you to specify a named parameter which, in effect, overrides the typical rules and directs the call to the first overload. Keep in mind this would only work if the method overloads had different parameter names for the same types (which in itself is weird). But it is a situation I had not considered before and it is one in which you should be aware of the rules that the C# 4 compiler applies.
posted on Tuesday, March 16, 2010 12:14 AM Print
Comments
Gravatar
# re: C# 4 Named Parameters for Overload Resolution
Oskar Austegard
3/16/2010 9:50 AM
Can you declare methods like this?

public void DoWork(int num) {/* do something */ }
public void DoWork(int num2) {/* do something else */ }
Gravatar
# re: C# 4 Named Parameters for Overload Resolution
Steve
3/16/2010 9:53 AM
@Oskar - No, the compiler does not let you do that.
Gravatar
# re: C# 4 Named Parameters for Overload Resolution
chris haas
3/18/2010 3:43 PM
I actually am not a fan of named parameters. They do make sense when you have 50 optional parameters like office development can be sometimes. Outside of that I think it clutters. That said, you gave one of the best presentations I have seen at philly.net in years....and gained a blog reader.

Post Comment

Title *
Name *
Email
Comment *  
Verification

View Steve Michelotti's profile on LinkedIn

profile for Steve Michelotti at Stack Overflow, Q&A for professional and enthusiast programmers




Google My Blog

Tag Cloud