What is the difference between virtual, override, and new keywords in C#?

These three keywords control how methods behave in inheritance hierarchies and are fundamental to understanding polymorphism in C#.

1. virtual Keyword:

• Marks a method in the base class as overridable
• Allows derived classes to provide their own implementation
• Enables runtime polymorphism

2. override Keyword:

• Used in derived classes to replace the virtual method implementation
• Provides runtime polymorphism - the correct method is called based on the actual object type
• Must override a virtual, abstract, or override method

3. new Keyword:

• Used for method hiding (not overriding)
• Creates a new method that hides the base class method
• Provides compile-time polymorphism - method called depends on reference type, not object type

Example:

public class Animal
{
    // Virtual method - can be overridden
    public virtual void MakeSound()
    {
        Console.WriteLine("Animal makes a sound");
    }
    
    // Regular method - can be hidden with 'new'
    public void Move()
    {
        Console.WriteLine("Animal moves");
    }
}

public class Dog : Animal
{
    // Override - runtime polymorphism
    public override void MakeSound()
    {
        Console.WriteLine("Dog barks: Woof!");
    }
    
    // Method hiding with 'new' - compile-time polymorphism
    public new void Move()
    {
        Console.WriteLine("Dog runs on four legs");
    }
}

public class Cat : Animal
{
    // Override - runtime polymorphism
    public override void MakeSound()
    {
        Console.WriteLine("Cat meows: Meow!");
    }
    
    // Method hiding with 'new' - compile-time polymorphism
    public new void Move()
    {
        Console.WriteLine("Cat walks gracefully");
    }
}

// Demonstration of the differences
public class PolymorphismDemo
{
    public static void DemonstratePolymorphism()
    {
        // Runtime Polymorphism (override)
        Animal animal1 = new Dog();
        Animal animal2 = new Cat();
        
        // Calls the overridden method based on actual object type
        animal1.MakeSound(); // Output: "Dog barks: Woof!"
        animal2.MakeSound(); // Output: "Cat meows: Meow!"
        
        // Compile-time Polymorphism (new)
        // Calls the method based on reference type, not object type
        animal1.Move(); // Output: "Animal moves" (base class method)
        animal2.Move(); // Output: "Animal moves" (base class method)
        
        // To call the hidden method, need to cast to derived type
        ((Dog)animal1).Move(); // Output: "Dog runs on four legs"
        ((Cat)animal2).Move(); // Output: "Cat walks gracefully"
        
        // Direct instantiation calls the correct method
        Dog dog = new Dog();
        Cat cat = new Cat();
        
        dog.MakeSound(); // Output: "Dog barks: Woof!"
        dog.Move();      // Output: "Dog runs on four legs"
        
        cat.MakeSound(); // Output: "Cat meows: Meow!"
        cat.Move();      // Output: "Cat walks gracefully"
    }
}

Key Differences Summary:

Best Practices:

• Use virtual in base classes when you want derived classes to customize behavior
• Use override when you want true polymorphism and method replacement
• Use new sparingly - only when you need to hide a method and don't want polymorphism
• Prefer override over new for better object-oriented design
• Always call base.MethodName() in overrides when you want to extend, not replace, functionality