Virtual Method in C#

Introduction

In C#, a virtual method is a method that can be overridden in a derived class. When a method is declared as virtual in a base class, it allows a derived class to provide its own implementation of the method.

To declare a method as virtual in C#, the "virtual" keyword is used in the method declaration in the base class. For example.

	public class Animal
	{
	    public virtual void MakeSound()
	    {
	        Console.WriteLine("The animal makes a sound");
	    }
	}

In the derived class, the method can be overridden by using the "override" keyword in the method declaration. For example.

	public class Cat : Animal
	{
	    public override void MakeSound()
	    {
	        Console.WriteLine("The cat meows");
	    }
	}

When an instance of the derived class is created and the overridden method is called, the implementation in the derived class will be executed instead of the implementation in the base class.

Using virtual methods can be useful in situations where you want to provide a base implementation in a base class, but allow derived classes to modify or extend the behavior of that method.

Virtual Method in C#

1. By default, methods are non-virtual. We can't override a non-virtual method.
2. 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 overrioverriddene 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 instaninstancesaccording to the run type the i, 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();  
	        }         
	    }  
	}

	using System;  
	  
	namespace VirtualExample  
	{     
	    class Shape  
	    {     
	       public double length=0.0;  
	       public double width =0.0;  
	       public double radius =0.0;   
	  
	       public Shape(double length, double width)  
	       {  
	           this.length = length;  
	           this.width = width;            
	       }  
	  
	       public Shape(double radius)  
	       {  
	           this.radius = radius;  
	       }  
	  
	       public  virtual void Area()  
	       {            
	           double area = 0.0;  
	           area = Math.PI * Math.Pow(radius, 2);  
	           Console.WriteLine("Area of Shape is :{0:0.00} ", area);  
	       }  
	    }   
	  
	    class Rectangle  : Shape  
	    {  
	  
	        public Rectangle(double length, double width): base(length, width)  
	        {  
	        }      
	  
	        public override void Area()  
	        {  
	            double area = 0.0;  
	            area = length * width;  
	            Console.WriteLine("Area of Rectangle is :{0:0.00} ", area);  
	        }  
	    }  
	     class Circle : Shape  
	    {  
	        public Circle(double radius)  
	            : base(radius)  
	        {  
	        }  
	    }    
	  
	    class Program  
	    {  
	        static void Main(string[] args)  
	        {  
	             double length,width,radius=0.0;  
	             Console.WriteLine("Enter the Length");  
	             length = Double.Parse(Console.ReadLine());  
	             Console.WriteLine("Enter the Width");  
	             width = Double.Parse(Console.ReadLine());  
	             Rectangle objRectangle = new Rectangle(length, width);  
	              objRectangle.Area();  
	             Console.WriteLine("Enter the Radius");  
	             radius = Double.Parse(Console.ReadLine());  
	             Circle objCircle = new Circle(radius);  
	             objCircle.Area();  
	            Console.Read();  
	        }         
	    }  
	}