Unlock the Power of Polymorphism in C#

What is Polymorphism?

Polymorphism, a fundamental concept in Object-Oriented Programming (OOP), allows a single entity to take on multiple forms. This means that a method, operator, or object can perform different operations in various scenarios, making your code more flexible and efficient.

A Simple Example

Let’s consider a class Program with two methods, both named greet(). One method takes no parameters and displays “Hello”, while the other takes a parameter and displays “Hello Tim”. This demonstrates how the same method can behave differently in different situations, making it polymorphic.

public class Program
{
    public void greet()
    {
        Console.WriteLine("Hello");
    }

    public void greet(string name)
    {
        Console.WriteLine($"Hello {name}");
    }
}

Types of Polymorphism in C#

There are two primary types of polymorphism in C#: Compile Time Polymorphism (Static Polymorphism) and Run-Time Polymorphism (Dynamic Polymorphism).

Compile Time Polymorphism

In Compile Time Polymorphism, the compiler determines which method to call at compile time. C# achieves this through two mechanisms:

• Method Overloading: Method overloading allows multiple methods with the same name to be created in a class, as long as they have different numbers or types of parameters. For example, a totalSum() method can be overloaded to calculate the sum of integers or doubles.
• Operator Overloading: Operator overloading enables operators to behave differently with various operands. For instance, the + operator can perform both numeric addition and string concatenation.

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

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

Run-Time Polymorphism

In Run-Time Polymorphism, the method to be called is determined at runtime. This is achieved through:

• Method Overriding: Method overriding occurs when a subclass provides a specific implementation for a method already defined in its superclass. This allows the same method to perform different operations in different classes.

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

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

Why Do We Need Polymorphism?

Polymorphism enables us to write consistent, flexible code that can adapt to different scenarios. Without polymorphism, we would need to create separate methods for each specific case, leading to code duplication and inconsistency. By using polymorphism, we can create a single method that behaves differently for various shapes, making our code more efficient and maintainable.