Polymorphism in CSharp

Polymorphism in CSharp

There are three kinds of polymorphism in CSharp:

Compile time polymorphism

• Also mentioned as Method Overloading
• Subclass extends the functionality of base class
• Base class instance cannot be casted to Subclass instance.

Runtime polymorphism

• Also mentioned as Method Overriding
• Subclass rewrite the functionality of the same method defined in base class
• The new modifier instructs the compiler to use your implementation instead of the base class implementation. Any code that is not referencing your class but the base class will use the base class implementation.
• The override modifier may be used on virtual methods and must be used on abstract methods. This indicates for the compiler to use the last defined implementation of a method. Even if the method is called on a reference to the base class it will use the implementation overriding it.
• new and override can work together to switch among different implementations along the inheritation tree.
• new is used for method hiding.
• virtual and override is used for method overriding.

Parametric polymorphism

• Generic Programming
• Same method, multiple types

Examples

Every instance of a class has “boxes” to hold methods.
When you mark a method as virtual it says make a new “box” and put a method in it.
When you mark a method as override in a derived class, it keeps the “box” from the base class and put a new method in it.
For instance:

class A {
    public void foo(){Console.WriteLine("A::foo");
}
class B : A {
    public new virtual void foo(){Console.WriteLine("B::foo");
}
class C : B {
    public override void foo(){Console.WriteLine("C::foo");
}

// test
A a = new A();
B b = new B();
C c = new C();

a.foo(); // A::foo
b.foo(); // B::foo
c.foo(); // C::foo

A ab = new B(); 
A ac = new C();
/*
A has a "box" named foo and so it emits code to invoke the method in that "box".
*/
ab.foo(); // A::foo
ac.foo(); // A::foo

B bc = new C();
/*
B has a "box" named foo and the method in it is C version because C overrides the method inside the "box"
*/
bc.foo(); // C::foo