Virtual Method in C#

C# virtual method is a method that can be redefined in derived classes. In C#, a virtual method has an implementation in a base class as well as derived the class. It is used when a method’s basic functionality is the same but sometimes more functionality is needed in the derived class. A virtual method is created in the base class that can be overriden in the derived class. We create a virtual method in the base class using the virtual keyword and that method is overriden in the derived class using the override keyword. When a method is declared as a virtual method in a base class then that method can be defined in a base class and it is optional for the derived class to override that method. The overriding method also provides more than one form for a method. Hence it is also an example for polymorphism. When a method is declared as a virtual method in a base class and that method has the same definition in a derived class then there is no need to override it in the derived class. But when a virtual method has a different definition in the base class and the derived class then there is a need to override it in the derived class. When a virtual method is invoked, the run-time type of the object is checked for an overriding member. The overriding member in the most derived class is called, which might be the original member, if no derived class has overridden the member.

By default, methods are non-virtual. We can’t override a non-virtual method.
We can’t use the virtual modifier with the static, abstract, private or override modifiers.

Difference between virtual and non-virtual methods

We have two classes; one is a “Vehicle” class and another is a “Cart” class. The “Vehicle” class is the base class that has two methods; one is a virtual method “Speed()” and another is a non-virtual method “Average()”. So the base class virtual method “Speed()” is overriden in the sub class. We have one more class “Program” (the execution class) that has an entry point where we create an instance of sub class “Cart” and that instance is assigned to the base class “Vehicle” type. When we call virtual and non-virtual methods by both class’s instance then according to the run type the instance virtual method implementation is invoked; in other words both class’s instances invoke the subclass override method and the non-virtual method invoked is determined based on the instance of the class.

using System;  
  
namespace VirtualExample  
{     
    class Vehicle  
    {     
       public double distance=0.0;  
       public double hour =0.0;  
       public double fuel =0.0;   
  
       public Vehicle(double distance, double hour, double fuel)  
       {  
           this.distance = distance;  
           this.hour = hour;  
           this.fuel = fuel;  
       }  
  
       public void Average()  
       {  
           double average = 0.0;  
           average = distance / fuel;  
           Console.WriteLine("Vehicle Average is {0:0.00}", average);  
       }  
  
       public virtual void Speed()  
       {  
           double speed = 0.0;  
           speed = distance / hour;  
           Console.WriteLine("Vehicle Speed is {0:0.00}", speed);  
       }  
    }   
  
    class Car : Vehicle  
    {  
        public Car(double distance, double hour, double fuel)  
            : base(distance, hour, fuel)  
        {  
        }  
      public void Average()  
        {  
            double average = 0.0;  
            average = distance / fuel;  
            Console.WriteLine("Car Average is {0:0.00}", average);  
        }  
  
        public override void Speed()  
        {  
            double speed = 0.0;             
            speed = distance / hour;  
            Console.WriteLine("Car Speed is {0:0.00}", speed);  
        }  
    }   
  
    class Program  
   {  
        static void Main(string[] args)  
        {  
             double distance,hour,fuel=0.0;  
             Console.WriteLine("Enter the Distance");  
             distance = Double.Parse(Console.ReadLine());  
             Console.WriteLine("Enter the Hours");  
             hour = Double.Parse(Console.ReadLine());  
             Console.WriteLine("Enter the Fuel");  
             fuel = Double.Parse(Console.ReadLine());  
             Car objCar = new Car(distance,hour,fuel);  
             Vehicle objVeh = objCar;  
             objCar.Average();  
             objVeh.Average();  
             objCar.Speed();  
             objVeh.Speed();  
            Console.Read();  
        }         
    }  
}

Invoked Virtual Method that override and not override in derived classes

We have three classes “Shape”,”Rectangle” and “Circle”. Class “Shape” is a base class. Both “Rectangle” and “Circle” are derived classes from the base class. Base class “Shape” has virtual method “Area()”. Virtual method “Area()” is overriden in the derived class “Rectangle” but not overriden in the derived class “Circle”. When the virtual methods are overriden in a derived class and that derived class uses an instance then invokes a derived class overriden method. When a virtual method is not overriden in a derived class and uses that derived class instance then invokes base class virtual method.