Virtual Methods and Method Overriding C#

VirtualMethods-And-MethodOverriding-InCSharp

In C# virtual methods are used for achieving polymorphism. The term "polymorphism" is a Greek word which means "having multiple forms". The "compile-time polymorphism" is achieved by "method overloading" and operator overloading while "run time polymorphism" is achieved by "method overriding". In this article, we will learn about virtual methods and overriding virtual methods in detail.

Watch our videos here

Introduction

Virtual methods are used to implement dynamic binding. It is also known as late binding or dynamic polymorphism. The virtual keyword can be used to modify a method, property, indexer, or event declaration which allows it to be overridden in a derived class.

Virtual Method

A method modified by the "virtual" keyword is known as a virtual method. The virtual method may be implemented differently in different inherited classes, and the call to these methods are decided at runtime.

When a virtual method is invoked, the run-time type of the object is checked for an overriding member. The overriding method in the most derived class is called, which might be the original method if no derived class has overridden the virtual method.

By default, all the methods are non-virtual, so you cannot override a non-virtual method. With the introduction of C# 8, interfaces can also have virtual methods.

Please read more about the interface virtual method here.

Virtual Method Fundamental Points

The "virtual" keyword must be used to make a method virtual because all the methods are non-virtual by default.
The "virtual" keyword must be used before the return type of the method.
The access modifier of the virtual method should be the same in both the base class and its derived class.
Virtual methods can be overloaded in C#.
Virtual methods can have both out and ref type parameters.
If the derived class also has a method with the same name and signature as the base class virtual method, then the base class method will be hidden in the derived class.
A virtual method can be overridden to sealed also in the derived class.

Virtual Method Fundamental Rules

A non-virtual method cannot be overridden and by default, all the class methods are non-virtual in C#.
Virtual methods can be overridden in the derived class, but it is not mandatory like abstract methods.
Virtual methods cannot be private in C#.
All the virtual methods must have to provide the body definition in C#.
A virtual method cannot be static or abstract in C#.
The virtual modifier cannot be used when overriding the virtual method i.e. virtual modifiers cannot be used with the override keyword.
A constructor or destructor cannot be virtual in C#. If you remember in C++ virtual destructor is allowed.

Why Virtual Methods

Virtual methods are used to achieve run time polymorphism in C#.
Normally, a virtual method is used in the base class when there is a common functionality for all the derived classes, but some derive classes may need some different functionality.

Example

// Author 	: Tech Point Fundamentals
// Website 	: www.techpointfunda.com
// Demo 	: Virtual Methods in C#

using System;

// Concrete class
public class BaseClass
{
  // Instance Constructor
  public BaseClass()
  {
      Console.WriteLine("BaseClass constructor is called");
  }

  // Virtual Method
  public virtual void Display()
  {
      Console.WriteLine("BaseClass virtual Display() method is called");
  }

  // Overloaded Virtual Method
  public virtual void Display( string messsage)
  {		
      Console.WriteLine("BaseClass Display() method is called from : " + messsage);
  }

  public virtual void Print()
  {
      Console.WriteLine("BaseClass virtual Print() method is called");
  }

  public virtual void Show()
  {
      Console.WriteLine("BaseClass virtual Show() method is called");
  }

  // Destructor
   ~BaseClass()
  {
      Console.WriteLine("BaseClass destructor is called");
  }
}

// Concrete Derived Class
public class DerivedClass : BaseClass
{
  // Instance Constructor
  public DerivedClass()
  {
      Console.WriteLine("DerivedClass constructor is called");
  }

  // Overriding virtual method
  public override void Display()
  {
      Console.WriteLine("DerivedClass overridden Display() method is called");
  }

  // Overriding virtual method as sealed
  public override sealed void Print()
  {
      Console.WriteLine("DerivedClass sealed overridden Print() method is called");
  }
}

// Concrete Child Class
public class ChildClass : DerivedClass
{	
  // Instance Constructor
  public ChildClass()
  {
      Console.WriteLine("ChildClass constructor is called");
  }

  // Overriding base class virtual method
  public override void Show()
  {
      Console.WriteLine("ChildClass overridden Show() method is called");
  }
}

public class Program
{
  public static void Main()
  {
	Console.WriteLine("\n-------------- Base Class -----------\n");
	BaseClass _baseClass = new BaseClass();
	_baseClass.Display();
	_baseClass.Display("Base Class Object");
	_baseClass.Print();
	_baseClass.Show();
	
	Console.WriteLine("\n-------------- Derived Class -----------\n");
	DerivedClass _derivedClass = new DerivedClass();
	
  	// Derived Class method will be called   
	_derivedClass.Display(); 
  
	// Base Class method i.e original method will be called   
	_derivedClass.Display("Derived Class Object"); 
  
	// Derived Class method will be called   
	_derivedClass.Print(); 
  
	// Base Class method i.e original method will be called  	
	_derivedClass.Show(); 
	
	Console.WriteLine("\n-------------- Child Class -----------\n");
	ChildClass _chidClass = new ChildClass();
  
	// Derived Class method will be called 
	_chidClass.Display(); 
  
	// Base Class method i.e original method will be called   	
	_chidClass.Display("Child Class Object"); 
  
	// Derived Class method will be called  
	_chidClass.Print(); 
  
	 // Child Class method will be called  	
	_chidClass.Show();
  }
}

Method Overriding

Method overriding is an example of dynamic polymorphism in C#. Method overriding is a feature that allows a child class to provide a specific implementation of a base class method.

The method which is overridden by an override declaration in the derived class is known as the "overridden base method". This override method is a new implementation of the method that is inherited from the base class.

A virtual method can be overridden in the derived class using the "override" keyword. The "virtual" modifier cannot be used with the "override" keyword. Also, the access modifier must be the same as the base class virtual method.

Virtual Method Overriding Vs Abstract Method Overriding

Overriding the virtual method is optional while overriding the abstract methods is mandatory.
It is an error to use the "virtual" modifier with the "override" keyword but the "abstract" modifier can be used with the "override" keyword.
Abstract methods can only be defined in an abstract class while virtual methods can be defined in non-abstract classes as well.

Please read more about the abstract method here.

Virtual Property

A property can also be declared as virtual in C#. Virtual properties behave just like virtual methods, except for the differences in declaration and invocation syntax.

The virtual property can be overridden in a derived class by including a property declaration that uses the override modifier.

Real Examples of Virtual Methods

System.Type abstract class contains a lot of virtual methods and properties like GetArrayRank(), GetEnumName(), GetEvents() etc.
System.Reflection.Assembly is an abstract class that contains a lot of virtual methods and properties like GetType(), GetSatelliteAssembly(), LoadModule() etc.
System.Object is a concrete class which contains Equals(), GetHashCode(), ToString() virtual methods.
System.Globalization.CultureInfo is a concrete class which contains Name, Calendar, DateTimeFormat, DisplayName etc virtual properties and Clone() virtual method.

Live Demo

Video Recommendation

Watch More Videos...

Tuesday, November 17, 2020

Virtual Methods and Method Overriding C#