Virtual vs Override vs New Keywords in C#

The purpose of writing this article is simple; to provide a simple and fresh demonstration of the basic differences between these three frequently used and confusing keywords in C# with some reference example. This article is purely for the beginner in C#.

Outlines

  • Overview
  • Introduction 
    • Virtual Keyword
    • Override Keyword
    • New Keyword
  • Demo Examples 
    • Sample Implementation
    • New Keyword
    • Virtual and Override Keyword
    • Method Overloading + Riding
  • Key Points
  • Conclusions

Overview

In this article I'll explain how virtual, override and new keywords vary by taking some set of examples respectively (some sort of functionality).
Finally there will be some key points to remember about all these 3 keywords.

Introduction

This introductory part will provide a brief introduction of all these 3 keywords. So here they are.

  • Virtual Keyword

    The Virtual keyword is used for generating a virtual path for its derived classes on implementing method overriding. The Virtual keyword is used within a set with an override keyword. It is used as:

    1. // Base Class  
    2. class A  
    3. {  
    4.     public virtual void show()  
    5.     {  
    6.         Console.WriteLine("Hello: Base Class!");  
    7.         Console.ReadLine();  
    8.     }  
    9. }  
     
  • Override Keyword

    The Override keyword is used in the derived class of the base class in order to override the base class method. The Override keyword is used with the virtual keyword, as in:

    1. // Base Class  
    2. class A  
    3. {  
    4.     public virtual void show()  
    5.     {  
    6.         Console.WriteLine("Hello: Base Class!");  
    7.         Console.ReadLine();  
    8.     }  
    9. }  
    10.   
    11. // Derived Class  
    12. class B : A  
    13. {  
    14.     public override void show()  
    15.     {  
    16.         Console.WriteLine("Hello: Derived Class!");  
    17.         Console.ReadLine();  
    18.     }  
    19. }  
     
  • New Keyword

    The New keyword is also used for polymorphism but in the case of method overriding. So what does overriding means? In simple words we can say that we are changing what the base class does for the derived class.

    It is implemented as:

    1. class A  
    2. {  
    3.     public void show()  
    4.     {  
    5.         Console.WriteLine("Hello: Base Class!");  
    6.         Console.ReadLine();  
    7.     }  
    8. }  
    9.   
    10. class B : A  
    11. {  
    12.     public new void show()  
    13.     {  
    14.         Console.WriteLine("Hello: Derived Class!");  
    15.         Console.ReadLine();  
    16.     }  
    17. }   

Demo Example

  • Sample Implementation

    Here's a simple implementation in C# without using any keywords. Do you think it will run fine, or will it show a runtime or compile-time errors?  Let's see:

    1. using System;  
    2. using System.Collections.Generic;  
    3. using System.Linq;  
    4. using System.Text;  
    5.   
    6. namespace Generics  
    7. {  
    8.     class A  
    9.     {  
    10.         public void show()  
    11.         {  
    12.             Console.WriteLine("Hello: Base Class!");  
    13.             Console.ReadLine();  
    14.         }  
    15.     }  
    16.   
    17.     class B : A  
    18.     {  
    19.         public void show()  
    20.         {  
    21.             Console.WriteLine("Hello: Derived Class!");  
    22.             Console.ReadLine();  
    23.         }  
    24.     }  
    25.   
    26.     class Polymorphism  
    27.     {  
    28.         public static void Main()  
    29.         {  
    30.             A a1 = new A();  
    31.             a1.show();  
    32.             B b1 = new B();  
    33.             b1.show();   
    34.             A a2 = new B();  
    35.             a2.show();  
    36.         }  
    37.     }  
    38. }  

    Output Window

    Sample Implementation Output

    It is showing some sort of output. That means there is neither a runtime nor a compile-time error. But it will definitely show a warning in Visual Studio. So do you want to know what it is and how to remove it?

    Keep reading and you will go through that.

    Warning Message

    Here's the warning message that you will get:

    Warning Message in Sample Implementation

    Solution

    The solution of this problem is already in the warning. Just read it carefully and you will get that. Yes you got that right, for removing that warning we need to use the new keyword.

    In the next sample demo example is showing you a simple demo snippet and implementation of the new keyword. (I hope now you will be getting why we are using the new keyword in here.) 

  • New keyword | Method Overhiding

    Here's a simple snippet of method overriding. So just go through it and guess the output:

    1. using System;  
    2. using System.Collections.Generic;  
    3. using System.Linq;  
    4. using System.Text;  
    5.   
    6. namespace Generics  
    7. {  
    8.     class A  
    9.     {  
    10.         public void show()  
    11.         {  
    12.             Console.WriteLine("Hello: Base Class!");  
    13.             Console.ReadLine();  
    14.         }  
    15.     }  
    16.   
    17.     class B : A  
    18.     {  
    19.         public new void show()  
    20.         {  
    21.             Console.WriteLine("Hello: Derived Class!");  
    22.             Console.ReadLine();  
    23.         }  
    24.     }  
    25.   
    26.     class Polymorphism  
    27.     {  
    28.         public static void Main()  
    29.         {  
    30.             A a1 = new A();  
    31.             a1.show();  
    32.             B b1 = new B();  
    33.             b1.show();   
    34.             A a2 = new B();  
    35.             a2.show();  
    36.         }  
    37.     }  
    38. }  

    Output Window

    New Keyword Output

    Explanation

    The procedure goes something like that:

    Method Overriding Explanation

  • Virtual and Override Keywords | Method Overriding

    This is a simple example of method overriding. Just go through it and guess the output again and also try to differentiate between the previous snippet and this snippet.

    1. using System;  
    2. using System.Collections.Generic;  
    3. using System.Linq;  
    4. using System.Text;  
    5.   
    6. namespace Generics  
    7. {  
    8.     class A  
    9.     {  
    10.         public virtual void show()  
    11.         {  
    12.             Console.WriteLine("Hello: Base Class!");  
    13.             Console.ReadLine();  
    14.         }  
    15.     }  
    16.   
    17.     class B : A  
    18.     {  
    19.         public override void show()  
    20.         {  
    21.             Console.WriteLine("Hello: Derived Class!");  
    22.             Console.ReadLine();  
    23.         }  
    24.     }  
    25.       
    26.     class Polymorphism  
    27.     {  
    28.         public static void Main()  
    29.         {  
    30.             A a1 = new A();  
    31.             a1.show();  
    32.             B b1 = new B();  
    33.             b1.show();  
    34.             A a2 = new B();  
    35.             a2.show();  
    36.         }  
    37.     }  
    38. }  

    Output Window

    Ouput of Override Keyword

    Explanation

    The flow goes something like that:

    Vitual Keyword Explanation
     
  • Overriding + Hiding | Together

    This snippet shows how both of these methods can work together in a same snippet. So just go through this and guess the output.

    1. using System;  
    2. using System.Collections.Generic;  
    3. using System.Linq;  
    4. using System.Text;  
    5.   
    6. namespace Generics  
    7. {  
    8.     class A  
    9.     {  
    10.         public virtual void show()  
    11.         {  
    12.             Console.WriteLine("Hello: Base Class!");  
    13.             Console.ReadLine();  
    14.         }  
    15.     }  
    16.       
    17.     class B : A  
    18.     {  
    19.         public override void show()  
    20.         {  
    21.             Console.WriteLine("Hello: Derived Class!");  
    22.             Console.ReadLine();  
    23.         }  
    24.     }  
    25.   
    26.     class C : B  
    27.     {  
    28.         public new void show()  
    29.         {  
    30.             Console.WriteLine("Am Here!");  
    31.             Console.ReadLine();  
    32.         }  
    33.     }  
    34.   
    35.     class Polymorphism  
    36.     {  
    37.         public static void Main()  
    38.         {  
    39.             A a1 = new A();  
    40.             a1.show();  
    41.             B b1 = new B();  
    42.             b1.show();  
    43.             C c1 = new C();  
    44.             c1.show();  
    45.             A a2 = new B();  
    46.             a2.show();  
    47.             A a3 = new C();  
    48.             a3.show();  
    49.             B b3 = new C();  
    50.             b3.show();  
    51.         }  
    52.     }  
    53. }  

    Output Window

    Overriding Output

    Explanation

    The flow goes something like that:

    Overriding Structure

Key Points

I am providing some key points about these keywords by taking a reference of method overloading and overriding concepts, since these keywords are used in these mechanisms.

Virtual and Override

  • Used in polymorphism implementation
  • Includes same method name and same params
  • Used in method overriding
  • It is also called runtime polymorphism
  • Causes late binding

New

  • It is also used in polymorphism concept
  • Includes the same method name and different params
  • Used in method overriding
  • It is compile-time polymorphism
  • Causes early binding

Conclusion

So did you like it, I hope you so!

Well I tried to provide just a brief sketch of these keywords, that are very necessary for a beginner in C# as well as in OOP. If you have a good understaind of OOP then you can take any object-oriented language in your pocket.

So just go through OOP first and then C# and if you are facing any problem then feel free to ping or message me.

Happy coding, Cheers!