New Keyword in Polymorphism

Smart Lucky

Hi
can any one tell me what is doing new Keyword i am not understanding

class BC
{
public void Display()
{
System.Console.WriteLine("BC::Display");
}
}

class DC : BC
{
new public void Display()
{
System.Console.WriteLine("DC::Display");
}
}
class TC : DC
{
new public void Display()
{
Console.WriteLine("TC::Display");
}
}

class Demo
{
public static void Main()
{
DC b;
b = new DC();
b.Display();
b = new TC();
b.Display();
//b = new TC();
//b.Display();
}
}

6 Replies

Know the answer? Post it — somebody with the same question will find it here.

Vulpes14y ago
Accepted answer
One of the differences between 'virtual' and 'new' is that 'virtual' is polymorphic but 'new' is not.

So, in the first program using 'virtual':

The first a.Foo() calls A's implementation because the variable 'a' refers to an A instance at runtime.

b.Foo() calls B's implementation because the variable 'b' refers to a B instance at runtime.

The second a.Foo() calls B's implementation because the variable 'a' now refers to a B instance at runtime.

In the second program using 'new':

The first a.Foo() calls A's implementation because the variable 'a' is a variable of type A.

b.Foo() calls B's implementation because the variable 'b' is a variable of type B.

The second a.Foo() still calls A's implementation because the variable 'a' is a variable of type A even though it refers to a B instance at runtime.

Sorry, I didn't understand the question in your last post - are you asking about the 'this' keyword?

0
Vulpes14y ago
Probably the most common use for this feature is when you are extending a class which you didn't write or don't want to change for some reason and this class contains a non-virtual method whose implementation you are not happy with from the viewpoint of the derived class.

You can therefore write a new method with the same name and use 'new' to hide the base class method from the users of your class.

If the base class method had been virtual, you could simply have overridden it in the derived class with your own implementation.

Notice that you can also hide a virtual method using 'new' but this is seldom done in my experience when you can override it instead.
0
Smart Lucky14y ago
Hi
no i mean new keyword...?
0
Smart Lucky14y ago
Hi can any one tell me the real use of this........?
0
Smart Lucky14y ago
Hi
Is below code right.........?

when can override a method..
with virtual->override keywords as bellow
using System;
    namespace Polymorphism
    {
        class A
        {
            public virtual void Foo() { Console.WriteLine("A::Foo()"); }
        }

        class B : A
        {
            public override void Foo() { Console.WriteLine("B::Foo()"); }
        }

        class Test
        {
            static void Main(string[] args)
            {
                A a;
                B b;

                a = new A();
                b = new B();
                a.Foo();  // output --> "A::Foo()"
                b.Foo();  // output --> "B::Foo()"

                a = new B();
                a.Foo();  // output --> "B::Foo()"
            }
        }
     }
but another way to override the method...
is new keyword instead of override..as bellow

using System;
    namespace Polymorphism
    {
        class A
        {
            public void Foo() { Console.WriteLine("A::Foo()"); }
        }

        class B : A
        {
            public new void Foo() { Console.WriteLine("B::Foo()"); }
        }

        class Test
        {
            static void Main(string[] args)
            {
                A a;
                B b;

                a = new A();
                b = new B();
                a.Foo();  // output --> "A::Foo()"
                b.Foo();  // output --> "B::Foo()"

                a = new B();
                a.Foo();  // output --> "A::Foo()"
            }
        }
    }

another example
class A
            {
                public void Foo() {}
            }

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

A class C can now declare a method Foo() that either overrides or hides Foo() from class B:
            class C : B
            {
                public override void Foo() {}
                // or
                public new void Foo() {}
            }
0
Vulpes14y ago
Quite simply, the 'new' keyword is hiding the Display() method inherited from the base class because the derived class has a method of the same name.

If you don't use 'new', the compiler will warn you that the derived class's Display() method is hiding the base class's Display() method but your program will still compile.

You can still access the base class method using the syntax : base.Display().

Notice also that 'new' is not polymorphic.

These two lines:

b = new TC();
b.Display();

display DC::Display (not TC::Display) on the console because 'b' is a variable of type DC (not TC) even though it currently refers to an object of type TC. Consequently, DC's version of Display() gets called.
0