C# - Virtual and Override Keyword

Virtual and Override Keyword in C# 

In C#, the virtual and override keywords are used to implement runtime polymorphism, allowing derived classes to provide specific implementations for methods defined in a base class. Here's an in-depth explanation of these keywords:

Virtual Keyword

The virtual keyword is used in a base class to indicate that a method, property, event, or indexer can be overridden in any derived class. When a method is marked as virtual, it means that the method has a default implementation in the base class, but derived classes can provide their own specific implementation.

Example 

public class Animal
{
    // Virtual method
    public virtual void MakeSound()
    {
        Console.WriteLine("Animal makes a sound");
    }
}

Override Keyword

The override keyword is used in a derived class to indicate that a method, property, event, or indexer is intended to override a member in the base class. The override keyword ensures that the method in the derived class has the same signature as the method in the base class and provides a new implementation for the base class's virtual method.

Example 

public class Dog : Animal
{
    // Override method
    public override void MakeSound()
    {
        Console.WriteLine("Dog barks");
    }
}

Detailed Example

Let's create a more detailed example to illustrate how virtual and override work together:

Base Class with Virtual Method

public class Animal
{
    // Virtual method
    public virtual void MakeSound()
    {
        Console.WriteLine("Animal makes a sound");
    }

    // Virtual property
    public virtual string Name
    {
        get { return "Animal"; }
    }
}

Derived Classes with Overridden Methods

csharp

public class Dog : Animal
{
    // Override method
    public override void MakeSound()
    {
        Console.WriteLine("Dog barks");
    }

    // Override property
    public override string Name
    {
        get { return "Dog"; }
    }
}

public class Cat : Animal
{
    // Override method
    public override void MakeSound()
    {
        Console.WriteLine("Cat meows");
    }

    // Override property
    public override string Name
    {
        get { return "Cat"; }
    }
}

Usage

public class Program
{
    public static void Main(string[] args)
    {
        Animal myAnimal = new Animal();
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        // Calling overridden methods
        myAnimal.MakeSound();  // Output: Animal makes a sound
        myDog.MakeSound();     // Output: Dog barks
        myCat.MakeSound();     // Output: Cat meows

        // Accessing overridden properties
        Console.WriteLine(myAnimal.Name); // Output: Animal
        Console.WriteLine(myDog.Name);    // Output: Dog
        Console.WriteLine(myCat.Name);    // Output: Cat
    }
}

Key Points

• Virtual Methods: Methods in the base class that can be overridden in derived classes. They provide a default implementation but can be replaced by a derived class.
• Override Methods: Methods in derived classes that replace the base class's virtual method. They must have the same signature as the method they override.
• Method Resolution: At runtime, the actual method that gets called is determined by the type of the object, not the type of the reference. This is known as dynamic method dispatch.

Practical Use Case

Consider a scenario where you have a base class for different types of employees, and each type of employee has a different way of calculating their bonus.

public class Employee
{
    public string Name { get; set; }
    public double Salary { get; set; }

    // Virtual method to calculate bonus
    public virtual double CalculateBonus()
    {
        return Salary * 0.1; // Base bonus calculation
    }
}

public class Manager : Employee
{
    // Override method to provide specific bonus calculation for managers
    public override double CalculateBonus()
    {
        return Salary * 0.2; // Managers get a higher bonus
    }
}

public class Developer : Employee
{
    // Override method to provide specific bonus calculation for developers
    public override double CalculateBonus()
    {
        return Salary * 0.15; // Developers get a mid-level bonus
    }
}

// Usage
public class Program
{
    public static void Main(string[] args)
    {
        Employee emp1 = new Manager() { Name = "Alice", Salary = 80000 };
        Employee emp2 = new Developer() { Name = "Bob", Salary = 60000 };

        Console.WriteLine($"{emp1.Name} Bonus: {emp1.CalculateBonus()}"); // Output: Alice Bonus: 16000
        Console.WriteLine($"{emp2.Name} Bonus: {emp2.CalculateBonus()}"); // Output: Bob Bonus: 9000
    }
}

Conclusion

In this example, the CalculateBonus method is defined as virtual in the Employee class and overridden in the Manager and Developer classes to provide specific implementations for each type of employee. When the CalculateBonus method is called on an Employee reference, the actual method executed depends on the runtime type of the object.

By understanding and using virtual and override keywords effectively, you can design flexible and maintainable object-oriented systems that leverage the power of polymorphism.

Thanks