Overloading base method in derived class

Question

So I was playing with C# to see if it matched C++ behavior from this post: http://herbsutter.com/2013/05/22/gotw-5-solution-overriding-virtual-functions/ when I came across this very strange behavior:

public class BaseClass
{
    public virtual void Foo(int i)
    {
        Console.WriteLine("Called Foo(int): " + i);
    }

    public void Foo(string i)
    {
        Console.WriteLine("Called Foo(string): " + i);
    }
}

public class DerivedClass : BaseClass
{
    public void Foo(double i)
    {
        Console.WriteLine("Called Foo(double): " + i);
    }
}

public class OverriddenDerivedClass : BaseClass
{
    public override void Foo(int i)
    {
        base.Foo(i);
    }

    public void Foo(double i)
    {
        Console.WriteLine("Called Foo(double): " + i);
    }
}

class Program
{
    static void Main(string[] args)
    {
        DerivedClass derived = new DerivedClass();
        OverriddenDerivedClass overridedDerived = new OverriddenDerivedClass();

        int i = 1;
        double d = 2.0;
        string s = "hi";

        derived.Foo(i);
        derived.Foo(d);
        derived.Foo(s);

        overridedDerived.Foo(i);
        overridedDerived.Foo(d);
        overridedDerived.Foo(s);
    }
}

Output

Called Foo(double): 1
Called Foo(double): 2
Called Foo(string): hi
Called Foo(double): 1
Called Foo(double): 2
Called Foo(string): hi

So apparently it favors the implicitly converted int to double over the more specific Foo(int) from the base class. Or does it hide the Foo(int) from the base class? But then: why isn't Foo(string) hidden? Feels very inconsistent... It also does not matter if I override Foo(int) or not; the outcome is the same. Can anyone explain what's going on here?

(Yes I know that it is bad practice to overload base methods in a derived class - Liskov and all - but I still wouldn't expect that Foo(int) in OverriddenDerivedClass isn't called?!)

"Yes I know that it is bad practice to overload base methods in a derived class - Liskov and all" Huh, what? When are you allowed to override base methods then? Anyway +1 because I would expect the same, curious for the answer. — bas
– bas, Commented May 23, 2013 at 8:33
@DimitarDimitrov Prayeth to the Skeet, so he may come bless us in the holy light of wisdom. — Nolonar
– Nolonar, Commented May 23, 2013 at 8:53
Speaking of the great Skeet: stackoverflow.com/questions/2744528/… — Corak
– Corak, Commented May 23, 2013 at 8:53
Can't go wrong with Eric Lippert responding to a Jon Skeet brainteaser. — Corak
– Corak, Commented May 23, 2013 at 8:59

Matthew Watson · Accepted Answer · 2013-05-23 09:01:15Z

10

To explain how it works for the OverriddenDerivedClass example:

Have a look at the C# spec for member lookup here: http://msdn.microsoft.com/en-us/library/aa691331%28VS.71%29.aspx

That defines how the lookup is done.

In particular, look at this part:

First, the set of all accessible (Section 3.5) members named N declared in T and the base types (Section 7.3.1) of T is constructed. Declarations that include an override modifier are excluded from the set.

In your case, N is Foo(). Because of Declarations that include an override modifier are excluded from the set then the override Foo(int i) is excluded from the set.

Therefore, only the non-overridden Foo(double i) remains, and thus it is the one that is called.

That is how it works for the OverriddenDerivedClass example, but this is not an explanation for the DerivedClass example.

To explain that, look at this part of the spec:

Next, members that are hidden by other members are removed from the set.

The Foo(double i) in DerivedClass is hiding the Foo(int i) from the base class, so it is removed from the set.

The tricky thing here is the part that says:

All methods with the same signature as M declared in a base type of S are removed from the set.

You might say "But wait! Foo(double i) doesn't have the same signature as Foo(int i), so it shouldn't be removed from the set!".

However, because there is an implicit conversion from int to double, it is considered to have the same signature, so Foo(int i) is removed from the set.

edited May 23, 2013 at 9:01

answered May 23, 2013 at 8:46

Matthew Watson

111k12 gold badges179 silver badges301 bronze badges

Sign up to request clarification or add additional context in comments.

6 Comments

Corak Over a year ago

((BaseClass)derived).Foo(i)

Nebula Over a year ago

Ok, thanks for that. But indeed: "...and t he base types (Section 7.3.1) of T... implies that BaseClass::Foo(int) would be within scope. What I can imagine is that the set looks like : DerivedClass::Foo(double), BaseClass::Foo(int). When it then takes the integer argument it knows it can implicitly convert an integer into a double and BaseClass::Foo(int) is not evaluated. This would only be true however when a normal class with Foo(double) Foo(int) has a set like this: NormalClass:Foo(int), NormalClass:Foo(double). Could we verify this?

Matthew Watson Over a year ago

@Nebula Sorry, not too sure what you mean... However, the base Foo(int) is in scope but because it has the same signature as the derived class Foo(double) (because there is an implicit conversion from int to double) the derived class's Foo(double) causes the base class's Foo(int) to be removed from the set.

Nebula Over a year ago

@MatthewWatson Yes, that is indeed what seems to happen. What is not clear to me however is how this decision is made: are derived methods favored over base class methods? Even if the type has to be converted (i.e. 'forced') to fit the signature? In other words, is it a decision made by the compiler (look at derived and base and compare sigatures) or does the compiler first look at the derived list first to see if it can make a match (any match at all, using implicit conversions and whatnot) and, if so, then disregards the base class altogether?

Matthew Watson Over a year ago

@Nebula It follows exactly the steps outlined by the spec (see the link I posted for the full spec). The only important thing which isn't defined by that part of the spec is the crucial point that methods from the base class that have parameter types which have implicit conversions from the corresponding parameter types in the derived method are considered to have the same signature. I can't find that in the spec... But Eric Lippert's blog that someone linked explains it better: blogs.msdn.com/b/ericlippert/archive/2007/09/04/…

|

Collectives™ on Stack Overflow

Overloading base method in derived class

1 Answer 1

6 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

6 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related