Why is C# calling the wrong overload?

Question

I have following code that really does funny stuff:

class Parent {
    public virtual void DoSomething(IEnumerable<string> list) {
        Console.WriteLine("Parent.DoSomething(IEnumerable<string>)");
    }
}

class Child : Parent {
    public override void DoSomething(IEnumerable<string> list) {
        Console.WriteLine("Child.DoSomething(IEnumerable<string>)");
    }

    public void DoSomething(IEnumerable<object> list) {
        Console.WriteLine("Child.DoSomething(IEnumerable<object>)");
    }
}

As you can see, the DoSomething method in Child is overridden correctly.

The output of the following code is very unexpected:

...
Child c = new Child();
var list = new List<string> { "Hello", "World!" };
c.DoSomething(list);
...

Prints Child.DoSomething(IEnumerable<object>)

Whereas assinging a Parent reference to c generates the correct output:

...
Parent c = new Child();
var list = new List<string> { "Hello", "World!" };
c.DoSomething(list);
...

Prints Child.DoSomething(IEnumerable<string>)

Why does this happen?!

Answer 1

It happens because the C# compiler obeys the spec :)

The specification says that if any method declared in a derived type is applicable, any methods originally declared in a base class (even if they're overridden in the derived type) are removed from the set of candidates.

Now because you're using C# 4 (presumably) there's an implicit conversion from List<string> to IEnumerable<object> so your Child.DoSomething(IEnumerable<object>) overload is applicable, and the compiler never really considers the one using IEnumerable<string>.

I have an article about overloading which goes into this and some other oddities.

I advise you not to overload across type hierarchies - it's confusing.