Using the 'new' modifier in C#

Question

I read that the new modifer hides the base class method.

using System;

class A
{
    public void Y()
    {
        Console.WriteLine("A.Y");
    }
}

class B : A
{
    public new void Y()
    {
        // This method HIDES A.Y.
        // It is only called through the B type reference.
        Console.WriteLine("B.Y");
    }
}

class Program
{
    static void Main()
    {
        A ref1 = new A(); // Different new
        A ref2 = new B(); // Polymorpishm
        B ref3 = new B();

        ref1.Y();
        ref2.Y(); //Produces A.Y line #xx
        ref3.Y();
    }
}

Why does ref2.Y(); produce A.Y as output?

This is simple polymorphism, the base class object pointing towards derived class, so it should call the derived class function. I am actually Java cum C# coder; these concepts just boggled my mind.

When we say new hides the base class function, that means the base class function can't be called, that's what hides mean as far as I know.

ref

Answer 1

In C#, methods are not virtual by default (unlike Java). Therefore, ref2.Y() method call is not polymorphic.

To benefit from the polymorphism, you should mark A.Y() method as virtual, and B.Y() method as override.

What new modifier does is simply hiding a member that is inherited from a base class. That's what really happens in your Main() method:

A ref1 = new A();
A ref2 = new B();
B ref3 = new B();

ref1.Y(); // A.Y
ref2.Y(); // A.Y - hidden method called, no polymorphism
ref3.Y(); // B.Y - new method called

Answer 2

(Just to supplement other answers, and comments by myself.)

When one uses new, the class (or struct, or interface) will have two same-looking members, one inherited from a base type, and one declared by the type itself. Avoid that!

Important: Just because you say new, you will not "remove" the old member. It is still there, and can easily be called. The new member does not replace the inherited one. It is an unrelated member which happens to have the same name.

It is not good to have two or more members in a type that look the same. It leads to confusion. Consider the code:

interface IOne
{
  void Y();
}
interface ITwo
{
  void Y();
}
interface IBoth : IOne, ITwo
{
}
class Test
{
  static void M(IBoth obj)
  {
    obj.Y();  // must not compile!
  }
}

The type IBoth has two members (both inherited) which look the same. Depending on what concrete class obj is, those methods might have different implementations. The call obj.Y() is ambiguous. You will have to cast obj to one of the base interfaces to resolve this.

Then consider this code:

interface IBase
{
  void Y();
}
interface IDerived : IBase
{
  /* new */ void Y();
}
class Test
{
  static void M(IDerived obj)
  {
    obj.Y();  // allowed; IDerived has two Y, but one hides the other
  }
}

This time, there are two Y(), but one is sort of "nearer" than the other one. So the nearer one is preferred. However the compiler will give you a warning if you don't use new. If you do use new, that changes nothing other than making the compile-time warning go away. It is really a bad idea to make two Y() on purpose.

This situation can happen if the base type (here IBase) is written by some other vendor/supplier. Example: Maybe you introduced Y() in your interface at a time when the base didn't have that functionality. But then the vendor of IBase is releasing a new version of their product where IBase has the Y(). Now if you compile your code against their new version, "your" Y() will still be called, not theirs. But it will give this warning. The warning goes away if you include new. But it is better to either (1) remove your Y() method completely if you determine that the vendor's Y() does the job, or (2) rename your Y() method to some unused name.

If what you wanted was polymorphism, of course use abstract/virtual (class members only) combined with override (in the inheriting class). override will not introduce any new members, just a new implementation of an existing (inherited) member. This can be done for non-static members (typically methods or properties) only.

Answer 3

The type of the object is A, but ref2 does not access the version of Y() that is defined in the B class because that method is declared with the new modifier, not the override modifier. As a result, a ref2 object displays the same description as an A object.