Overriding Vs Shadowing in C#

Method Overriding

Method overriding is an important feature of OOP that allows us to re-write a base class function or method with a different definition. Overriding is also known as “Dynamic polymorphism” because overriding is resolved at runtime. Here the signature of the method or function must be the same. In other words both methods (base class method and child class method) have the same name, same number and same type of parameter in the same order with the same return type. The overridden base method must be virtual, abstract or override.

Example

public class BaseClass  
{  
    public virtual string GetMethodOwnerName()  
    {  
       return “Base Class”;  
    }  
}  
public class ChildClass : BaseClass  
{  
   public override string GetMethodOwnerName()  
   {  
       return “Child Class”;  
   }  
} 

A method cannot be overriden if:

• Methods have a different return type
• Methods have a different access modifier
• Methods have a different parameter type or order
• Methods are non virtual or static

Shadowing (method hiding)

A method or function of the base class is available to the child (derived) class without the use of the "overriding" keyword. The compiler hides the function or method of the base class. This concept is known as shadowing or method hiding. In the shadowing or method hiding, the child (derived) class has its own version of the function, the same function is also available in the base class.

Example

Public class BaseClass  
{  
    public string GetMethodOwnerName()  
    {  
       return "Base Class";  
    }  
}  
public class ChildClass : BaseClass  
{  
    public new string GetMethodOwnerName()  
    {  
       return "ChildClass";  
    }  
} 

Test Code

static void Main(string[] args)  
{  
    ChildClass c = new ChildClass();  
    Console.WriteLine(c.GetMethodOwnerName());  
}

Output

If we do not use the new keyword the compiler generates the warning:

Mixing Method (Overriding and shadowing (Method Hiding))

We can also use shadowing and method overriding together using the virtual and new keywords. This is useful when we want to further override a method of the child (derived) class.

Example

public class BaseClass  
{  
    public virtual string GetMethodOwnerName()  
    {  
        return "Base Class";  
    }  
}  
public class ChildClass : BaseClass  
{  
    public new virtual string GetMethodOwnerName()  
    {  
        return "ChildClass";  
    }  
}  
public class SecondChild : ChildClass  
{  
    public override virtual string GetMethodOwnerName()  
    {  
        return "Second level Child";  
    }  
} 

Shadowing Vs Overriding

static void Main(string[] args)  
{  
    BaseClass c = new ChildClass();  
    Console.WriteLine(c.GetMethodOwnerName());  
} 

static void Main(string[] args)  
{  
    BaseClass c = new ChildClass();  
    Console.WriteLine(c.GetMethodOwnerName());  
}