C# - Polymorphism

Polymorphism in C# 

Introduction to C# Polymorphism

C# Polymorphism is one of the four fundamental pillars of Object-Oriented Programming (OOP) in C#. Along with Encapsulation, Abstraction, and Inheritance, polymorphism plays a crucial role in designing scalable, maintainable, and flexible applications in the .NET Framework and modern .NET Core environments.

The word polymorphism is derived from two Greek words: “poly” meaning many, and “morph” meaning forms. In simple terms, polymorphism means “many forms.” In C#, it allows methods, objects, and operators to behave differently based on the context in which they are used.

In real-world software development using C#, polymorphism enables developers to write reusable, clean, and loosely coupled code. It enhances flexibility in application architecture and allows different objects to respond to the same method call in different ways.

What is Polymorphism in C#?

Polymorphism in C# allows a single interface, method, or function name to represent multiple implementations. It enables one method to perform different tasks depending on the object that invokes it.

In C#, polymorphism is achieved in two major ways:

• Compile-Time Polymorphism (Static Polymorphism)
• Runtime Polymorphism (Dynamic Polymorphism)

Understanding both types is essential for mastering Object-Oriented Programming in C#.

Types of Polymorphism in C#

1. Compile-Time Polymorphism in C#

Compile-time polymorphism is also known as Static Polymorphism. It is achieved through:

• Method Overloading
• Operator Overloading

The method call is resolved at compile time. The compiler determines which method to invoke based on method signature.

Method Overloading in C#

Method overloading occurs when multiple methods have the same name but different parameters (type, number, or order).

Example: Method Overloading

using System;

class Calculator
{
    public int Add(int a, int b)
    {
        return a + b;
    }

    public double Add(double a, double b)
    {
        return a + b;
    }

    public int Add(int a, int b, int c)
    {
        return a + b + c;
    }
}

class Program
{
    static void Main()
    {
        Calculator calc = new Calculator();

        Console.WriteLine(calc.Add(10, 20));
        Console.WriteLine(calc.Add(10.5, 20.5));
        Console.WriteLine(calc.Add(5, 10, 15));
    }
}

In this example, the method Add behaves differently depending on parameters. This is a classic demonstration of compile-time polymorphism in C#.

Operator Overloading in C#

C# allows redefining the behavior of operators for user-defined types.

using System;

class Complex
{
    public int Real;
    public int Imaginary;

    public Complex(int r, int i)
    {
        Real = r;
        Imaginary = i;
    }

    public static Complex operator +(Complex c1, Complex c2)
    {
        return new Complex(c1.Real + c2.Real, c1.Imaginary + c2.Imaginary);
    }
}

This example shows how the + operator is overloaded for a custom class.

2. Runtime Polymorphism in C#

Runtime polymorphism is also known as Dynamic Polymorphism. It is achieved through:

• Method Overriding
• Virtual Methods
• Abstract Methods
• Interface Implementation

The method call is resolved at runtime using dynamic method dispatch.

Method Overriding in C#

Method overriding occurs when a derived class provides a specific implementation of a method that is already defined in the base class using the virtual keyword.

Rules for Method Overriding:

• Base class method must be marked as virtual.
• Derived class method must use override keyword.
• Method signature must be the same.

Example: Runtime Polymorphism in C#

using System;

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

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

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

class Program
{
    static void Main()
    {
        Animal a1 = new Dog();
        Animal a2 = new Cat();

        a1.Speak();
        a2.Speak();
    }
}

Even though the reference type is Animal, the method executed depends on the object type at runtime. This is true runtime polymorphism in C#.

Virtual Methods in C#

A virtual method allows a derived class to override it. It supports runtime polymorphism.

Virtual methods provide flexibility while maintaining a default implementation.

Abstract Class and Polymorphism in C#

An abstract class cannot be instantiated and may contain abstract methods without implementation.

using System;

abstract class Shape
{
    public abstract double CalculateArea();
}

class Circle : Shape
{
    public double Radius;

    public Circle(double r)
    {
        Radius = r;
    }

    public override double CalculateArea()
    {
        return 3.14 * Radius * Radius;
    }
}

Abstract methods enforce derived classes to implement specific behavior, strengthening runtime polymorphism in C#.

Interface and Polymorphism in C#

Interfaces provide 100% abstraction and allow multiple inheritance in C#.

using System;

interface IPayment
{
    void ProcessPayment();
}

class CreditCard : IPayment
{
    public void ProcessPayment()
    {
        Console.WriteLine("Processing Credit Card Payment");
    }
}

class PayPal : IPayment
{
    public void ProcessPayment()
    {
        Console.WriteLine("Processing PayPal Payment");
    }
}

Here, different classes implement the same interface differently. This demonstrates runtime polymorphism using interfaces in C#.

Difference Between Compile-Time and Runtime Polymorphism

Real-World Example of Polymorphism in C#

Polymorphism is widely used in enterprise-level applications such as:

• Payment gateway systems
• Logging frameworks
• Notification services
• Dependency Injection in ASP.NET Core
• Repository pattern implementations

For example, in ASP.NET Core applications, services are injected through interfaces, enabling runtime polymorphism.

Advantages of Polymorphism in C#

• Improves code reusability
• Enhances scalability
• Supports loose coupling
• Encourages clean architecture
• Improves maintainability
• Reduces code duplication

Polymorphism and SOLID Principles

Polymorphism directly supports:

• Open/Closed Principle
• Liskov Substitution Principle
• Dependency Inversion Principle

Using runtime polymorphism ensures that new features can be added without modifying existing code.

C# Polymorphism is a powerful concept in Object-Oriented Programming that enables flexibility, scalability, and maintainability in software development. Understanding compile-time polymorphism (method overloading) and runtime polymorphism (method overriding, interfaces, abstract classes) is essential for mastering C# programming.

By implementing polymorphism effectively, developers can build enterprise-level applications using .NET Framework and .NET Core with clean architecture and SOLID design principles.