What if I don't heed the warning “hides inherited member. To make the current member override that implementation…”

Question

This is maybe a fine point, but it concerns the warning that the compiler issues if you do something like:

class A
{
    public virtual void F() { }
}
class B :          


        

Answer 1

It will not do anything but the method you have there F() is also not polymorphic. It becomes very easy to make mistake in code if you started to use base class reference hence you are warned. Of course it can be what you want, hence the new keyword just make it more explicit

E.g.

B b1 = new B();
b1.F(); // will call B.F()

A b2 = new B();
b2.F(); // will call A.F()

Now, if you add class C with new, it will behave the same as B. If you add class D with override, then F becomes polymorphic:

class C : A
{
    public new void F() { }
}

class D : A
{
    public override void F() { }
}

// Later

C c1 = new C();
c1.F(); // will call C.F()

A c2 = new C();
c2.F(); // will call A.F()

D d1 = new D();
d1.F(); // will call D.F()

A d2 = new D();
d2.F(); // will call D.F()

See this fiddle.

Answer 2

This is just warning. Code will work. In some circumstance, this warning can lead to some problem.

use new keyword with the method which you are calling from the base class.

class A
{
    public virtual void F() { }
}
class B : A
{
   new public void F() { }
}

Reference

https://msdn.microsoft.com/en-us/library/435f1dw2.aspx

https://msdn.microsoft.com/en-us/library/aa691135(v=vs.71).aspx

Answer 3

No, the default behaviour is exactly the same as if you use new, other than whether the warning is given. In my experience you more often actually want to specify override instead of new, as it's usually just a case of forgetting to explicitly override.

If you really do want a completely separate method, and if you've got the option of using a different name instead, I'd take that approach. Having one method hiding another usually reduces readability significantly IMO. It's not too bad if the purpose is to just give a more specific return type (and you make sure the more weakly typed method returns the same value), but that's a pretty rare case.