c# method with default parameter value does not generate overload without parameter?

Question

Recently, I wanted to add an optional parameter to an extension method. The original method looked like this:

public static class Extensions {
    public static bool Foo(this IFoo target) {
        target.DoIt(true);
    }
}

This is obviously a simplified version but let's go from that.

What I did is:

public static class Extensions {
    public static bool Foo(this IFoo target, bool flag = true) {
        target.DoIt(flag);
    }
}

All I did is introduce an optional parameter with a default value, right? What I was expecting was the compiler to generate the overloaded method, without the flag. This partially happened. Any code that I recompiled was able to compile and execute without any problems, even without the parameter like this:

...
IFoo foo = new FooBar();
foo.Foo();
...

However, any code that was built against the previous version of Foo() did not work, throwing the following exception:

Unhandled Exception: System.MissingMethodException: Method not found: 'Boolean Models.Class1.Foo()'.
at DefaultParamsTests.Program.Main(String[] args)

This is obviously a problem for us as we do have a public API that our customers do leverage and this would be a breaking change.

The solution is to explicitly create an overload:

public static class Extensions {
    public static bool Foo(this IFoo target) {
        target.DoIt(true);
    }

    public static bool Foo(this IFoo target, bool ) {
        target.DoIt(true);
    }
}

However, Resharper does suggest that I could introduce an optional parameter for method foo.

If I do follow the refactoring it basically does what I showed above. However, that won't work for existing code.

I have looked at the generated IL using both Reflector and dotPeek. Neither is showing the generation of the overload.

What am I missing?

Answer 1

In the case of default parameters, the actual call site is re-written to use the default value. This means an overload isn't generated at all, your calling code is modified!

public void fun(int x = 3) { }

// in another file
fun();   // compiler re-writes to fun(3);
fun(7);  // fun(7) as expected

// actual code generated by the c# compiler
fun(3);
fun(7);

If you use optional parameters in C# you need to re-compile all callers when the function changes. For this reason it is strongly discouraged to put these kind of methods on a public interface (e.g. called by other's code). Using them inside your own linked projects is fine, since they should all compile at the same time

Answer 2

Optional parameters in methods in C# are resolved at compile-time at the call site. Your calling code that omits the parameter expands to include the parameter, calling the two-parameter version. This is the opposite of what you are presuming happens, with creating an overload.

Answer 3

The key here is that the compiler changes the caller of the method to include the default value.

Take a look at the NEW code in dotPeek.

NOTE: You should delete the pdb files when using dotPeek on your own files!

Here is an extensions class with two methods (decompiled with dotPeek). One with a default and one without

public static class Extensions
{
    public static bool Foo(this IFoo target)
    {
        return target.DoIt(true);
    }

    public static bool Foo(this IFoo2 target, bool doit = false)
    {
        return target.DoIt2(doit);
    }
}

Everything looks fine there. Now look at the object calling the extension method (decompiled with dotPeek).

public class Bar
{
    public Bar(IFoo foo)
    {
        Extensions.Foo(foo);
    }

    public Bar(IFoo2 foo)
    {
        Extensions.Foo(foo, false);
    }
}

Notice that the caller to the IFoo2 extension method actually contains the value false to the method Foo of class Extensions. So your method Extensons.Foo now has two parameters in it. The first method the object and the second being the "default" parameter. So any code that was created with the first version will now fail because there is no method with only one parameter.

Disable resharper around the methods and you won't see it pester you anymore :)