Static method hides instance method ! Anybody, please throw light!

Question

Edit: I have asked question to understand why C# designers chose it to behave in particular fashion?

Similar question has been asked, but this is little different.

Should following code give warning?

class Foo { public void Do() { /*...*/ } /*...*/ }
class Bar : Foo { public static void Do()  { /*...*/ } /*...*/ }

It gives: "warning CS0108: 'Bar.Do()' hides inherited member 'Foo.Do()'. Use the new keyword if hiding was intended."

Let me make a change in code.

class Foo { public static void Do() { /*...*/ } /*...*/ }
class Bar : Foo { public void Do()  { /*...*/ } /*...*/ }

Same warning.

If you do following, warning goes away.

class Foo { public void Do() { /*...*/ } /*...*/ }
class Bar : Foo { new public static void Do() { /*...*/ } /*...*/ }

Let me make further change.

class Foo { public void Do() { /*...*/ } /*...*/ }
class Bar : Foo { 
    new public static void Do() 
    { new Bar().Do();/*...*/ } /*...*/ 
}

This does not compile. error CS0176: Member 'Bar.Do()' cannot be accessed with an instance reference; qualify it with a type name instead.

So, I lose access to inherited method via instance reference from static method!

What would be logic behind it? Or I made a typo somewhere?

Btw, I come across this when I was trying to define static method 'Show' for my form derived from 'Form'.

Answer 1

No, that makes perfect sense. This works as expected:

using System;
using System.Collections.Generic;

class Foo { public void Do() { /*...*/ } /*...*/ }
class Bar : Foo { 
    new public static void Do() 
    { ((Foo)new Bar()).Do();/*...*/ } /*...*/ 
}

That's because the compiler assumes that you have a Bar type, and then finds the static member. By casting it to Foo (which comes for free btw.) you make it look in the metdadata for Foo() and all is fine.

Answer 2

Try this:

        new public static void Do()
        { 
            ((Foo)new Bar()).Do(); 
        }

Answer 3

In your final code sample, the new keyword on the declaration of Bar.Do() means that you intended to hide Foo.Do().

Answer 4

Out of curiosity, why do you want to do this? It seems like you are probably going about your solution the wrong way.

The above code appears to work as it should, and the compiler messages tell you what the problems are.

Answer 5

Where do you think the bug is? The fact that there is a warning is absolutely right. From the C# 3.0 spec, section 10.3.4:

A class-member-declaration is permitted to declare a member with the same name or signature as an inherited member. When this occurs, the derived class member is said to hide the base class member. Hiding an inherited member is not considered an error, but it does cause the compiler to issue a warning. To suppress the warning, the declaration of the derived class member can include a new modifier to indicate that the derived member is intended to hide the base member.

The fact that your method invocation fails is subtler, but it's basically because the member lookup algorithm picks the static method, and then this part of section 7.5.5.1 is used:

Final validation of the chosen best method is performed:

The method is validated in the context of the method group: If the best method is a static method, the method group must have resulted from a simple-name or a member-access through a type. If the best method is an instance method, the method group must have resulted from a simple-name, a member-access through a variable or value, or a base-access. If neither of these requirements is true, a compile-time error occurs.