Ambiguity with inheriting an optional-parameter base method

I have a base class with one optional default parameter, which a child class automatically provides a value for:

public class Merchant
{
    public string WriteResults(List<string> moreFields = null)
    {

        List<string> ListOfObjects = new List<string>() {Name, Address};
        if (moreFields != null)
        {
            ListOfObjects.AddRange(moreFields);
        }
            return ListOfObjects.ToString() //not real output
}


public class SpecificMerchant : Merchant 
{   
    new public string WriteResults()
        {
            return ((Merchant)this).WriteResults(new List<string>() {
                    Address, Phone //clas开发者_如何转开发s-specific parameters
            });
        }
}

I used the new keyword when calling SpecificMerchant.WriteResults because both the parent and the base can take no parameters, but the compiler says this is unnecessary:

The member 'SpecificMerchant.WriteResults()' does not hide an inherited member. The new keyword is not required.

Why? Aren't I, in practice, overriding the parent method?

No, you're not overriding it. You're providing a method with a different signature. Consider this:

new SpecificMerchant().WriteResults(new List<string>());

Could that possibly call the method in SpecificMerchant? No - you've specified an argument, and SpecificMerchant.WriteResults doesn't specify any parameters. That fact alone shows that it couldn't possibly override Merchant.WriteResults.

Your code could certainly cause confusion, as overloading in a type hierarchy often does even without optional parameters - but as far as the C# compiler and the CLR are concerned, these are very different methods... It so happens that both would be validate for a call with no arguments specified, but that's a different matter.

Because optional parameters are a compile time construct, not a runtime construct.

Your base class is always going to have a method with one parameter. The compiler just "substitutes" null at compile time if you call that method without an argument.

That being said, I would avoid trying to do what you're implementing above. Even if you remove the new keyword, which will let it compile, you're adding a lot of confusion. I would, personally, make the base class implementation virtual, if required, or add two methods to the base class and override one instead of using optional arguments.

For a good resource, I'd recommend reading James Michael Hare's post on Optional Parameters - He discusses the pitfalls, like this one, when you mix optional arguments with inheritance.