C# Possible method name conflicts with optional parameters - why it is not forbidden? [closed]

Question

Let's have a simple class, and main method:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;

namespace Rextester
{
public class Program
{
    public static void Main(string[] args)
    {
       bar bar = new bar();
        bar.foo("a");
    }
}

public class bar
{
    public void foo(String a, String b = "b")
    {
        Console.WriteLine("Foo1");            
    }       

}
}

This will write

Foo1

into the console.

Now, let's add an overload of the method into the class, using optional parameters:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;

namespace Rextester
{
public class Program
{
    public static void Main(string[] args)
    {
       bar bar = new bar();
        bar.foo("a");
    }
}

public class bar
{
    public void foo(String a, String b = "b")
    {
        Console.WriteLine("Foo1");            
    }

     public void foo(String a)
    {
        Console.WriteLine("Foo2");            
    }


}
}

This will write

Foo2

into the console.

I was expecting compile time error because I expect that foo(String a, String b = "b") represents both foo(String a) and foo(String a, String b) signature, because of the optional parameters. But I was wrong. Why is this allowed?

Answer 1

To start with an important quote from Eric Lippert

A lot of people seem to think that this:

void M(string x, bool y = false) { … whatever … }

is actually a syntactic sugar for the way you used to have to write this in C#, which is:

void M(string x) { M(x, false); }
void M(string x, bool y) { … whatever … }

But it is not. The syntactic sugar here is not on the declaration side, but rather on the call side. There is only one method; when you make a call that omits optional arguments, the compiler simply inserts the arguments at the call site. That is:

M(“hello”);

is rewritten as

M(“hello”, false);

I would recommend reading the whole series to really understand C#'s implementation of optional argument as call site rewriting. Basically your expectation

I expect that foo(String a, String b = "b") represents both foo(String a) and foo(String a, String b) signature

Is not how it works. Instead foo(String a, String b = "b") actually represents only foo(String a, String b). An example that Eric Lippert provides for why your intution would not work, is suppose that we had foo(String a = "a", String b = "b"). In this case one cannot nicely generate foo(String).

So that is why foo(String a, String b = "b") and foo(String a) can legitimately belong to the same class (because the optional parameter is filled in for callers rather than changing the declaration). Though it is a natural result of the implementation of optional parameters, it is clearly also error prone so there is still a question of why it is not disallowed.

I don't have a definitive answer here, and really only people involved in C#'s development could say, but to paraphrase Eric Lippert elsewhere, every feature in a language has an implementation cost; features that the designers don't feel are worth the cost just don't get implemented. In this case, making this probably incorrect code illegal is a feature with a definite cost and only marginal benefits (are people really mixing optional paramters and overrides in this way?) so it does not get implemented.

Answer 2

When you write any method call, the compiler will determine which method is called with which parameters. There will be a phase where the compiler determines all methods that could be called, then it complains if the number is zero, and it will try to determine the best one to call if there is more than one, complaining if it cannot decide.

In this case, the language has a rule that prefers a function with fewer parameters. I personally don't think this is a good rule, but Microsoft doesn't agree with my view. Had you overloaded as

public func foo (String a, String c = "c")

you would have got a warning.