Topic 7312 min readStructured Tutorial

Run-Time Polymorphism in C#

Quick Answer

Run-time polymorphism in C# allows methods to be overridden in derived classes and resolved dynamically during program execution. It enables flexible and extensible code by using virtual methods and method overriding, supporting dynamic behavior based on object types at runtime.

Learning Objectives

Explain the purpose of Run-Time Polymorphism in a practical learning context.
Identify the main ideas, terms, and decisions involved in Run-Time Polymorphism.
Apply Run-Time Polymorphism in a simple real-world scenario or practice task.

Introduction to Run-Time Polymorphism

Polymorphism is a core concept in object-oriented programming that allows objects to be treated as instances of their parent class rather than their actual class.

Run-time polymorphism, also known as dynamic polymorphism, occurs when a call to an overridden method is resolved at runtime rather than compile time.

This tutorial explains how run-time polymorphism works in C#, why it is useful, and how to implement it using virtual and override keywords.

Polymorphism allows the same interface to be used for different underlying forms (data types).

Understanding Run-Time Polymorphism

Run-time polymorphism enables a program to decide at runtime which method implementation to invoke based on the actual object type.

This is achieved in C# through method overriding, where a derived class provides a specific implementation of a method declared in its base class.

Base class declares a method as virtual.
Derived class overrides the virtual method using the override keyword.
Method calls on base class references invoke the derived class's method if the object is of the derived type.

Virtual and Override Keywords

The virtual keyword in the base class marks a method as overridable.

The override keyword in the derived class provides a new implementation for the virtual method.

virtual: Allows a method to be overridden in derived classes.
override: Provides the new implementation in the derived class.

How Dynamic Binding Works

When a virtual method is called through a base class reference, the runtime determines the actual object type and invokes the appropriate method implementation.

This mechanism is called dynamic binding or late binding.

Example of Run-Time Polymorphism in C#

Let's look at a simple example demonstrating run-time polymorphism using virtual and override methods.

Practical Example

In this example, the Speak method is declared virtual in the Animal base class and overridden in Dog and Cat derived classes. The method call on the Animal reference resolves at runtime to the appropriate derived class implementation.

Examples

Run-Time Polymorphism Example in C#

using System;

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

class Dog : Animal
{
    public override void Speak()
    {
        Console.WriteLine("The dog barks.");
    }
}

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

class Program
{
    static void Main()
    {
        Animal myAnimal = new Dog();
        myAnimal.Speak();  // Output: The dog barks.

        myAnimal = new Cat();
        myAnimal.Speak();  // Output: The cat meows.
    }
}

Best Practices

Always declare base class methods as virtual if they are intended to be overridden.
Use the override keyword in derived classes to provide specific implementations.
Avoid calling virtual methods from constructors to prevent unexpected behavior.
Keep overridden methods consistent with the base method's contract.
Use polymorphism to write flexible and maintainable code.

Common Mistakes

Forgetting to mark the base class method as virtual.
Using new keyword instead of override, which hides the base method instead of overriding.
Calling overridden methods from base class constructors.
Not understanding that method calls are resolved at runtime, leading to unexpected results.

Hands-on Exercise

Implement Run-Time Polymorphism

Create a base class Shape with a virtual method Draw. Derive classes Circle and Rectangle that override Draw with their specific implementations. Instantiate objects of each and call Draw through a base class reference.

Expected output: Calling Draw on a Shape reference should invoke the correct derived class method, printing shape-specific messages.

Hint: Use virtual in the base class and override in derived classes.

Interview Questions

What is run-time polymorphism in C#?

Interview

Run-time polymorphism in C# is the ability of a method call to resolve to different method implementations at runtime based on the actual object type, achieved through virtual methods and method overriding.

How do you implement run-time polymorphism in C#?

Interview

By declaring a method as virtual in the base class and overriding it in derived classes using the override keyword.

What is the difference between method overriding and method overloading?

Interview

Method overriding replaces a base class method in a derived class with the same signature and is resolved at runtime, while method overloading defines multiple methods with the same name but different parameters and is resolved at compile time.