C# Polymorphism

Polymorphism is one of the four fundamental principles of Object-Oriented Programming (OOP), along with Encapsulation, Inheritance, and Abstraction. The term polymorphism is derived from the Greek words "poly" (many) and "morph" (form), meaning the ability to take many forms. In C#, polymorphism allows objects to be treated as instances of their base type rather than their actual derived type.

1. Purpose of Polymorphism

2. Types of Polymorphism in C#

3. Compile-Time Polymorphism

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("Add(int, int): " + calc.Add(1, 2));          // Output: 3
        Console.WriteLine("Add(double, double): " + calc.Add(1.5, 2.5)); // Output: 4
        Console.WriteLine("Add(int, int, int): " + calc.Add(1, 2, 3));   // Output: 6
    }
}

Output:
Add(int, int): 3
Add(double, double): 4
Add(int, int, int): 6

using System;

struct Complex
{
    public double Real { get; }
    public double Imaginary { get; }

    public Complex(double real, double imaginary)
    {
        Real = real;
        Imaginary = imaginary;
    }

    // Overloading the + operator
    public static Complex operator +(Complex a, Complex b)
    {
        return new Complex(a.Real + b.Real, a.Imaginary + b.Imaginary);
    }

    public override string ToString()
    {
        return $"{Real} + {Imaginary}i";
    }
}

class Program
{
    static void Main()
    {
        Complex c1 = new Complex(1.0, 2.0);
        Complex c2 = new Complex(3.0, 4.0);
        Complex sum = c1 + c2;
        Console.WriteLine("Sum: " + sum); // Output: Sum: 4 + 6i
    }
}

Output:
Sum: 4 + 6i

4. Runtime Polymorphism

using System;

class Animal
{
    public virtual void Speak()
    {
        Console.WriteLine("Animal speaks");
    }
}

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 myAnimal;

        myAnimal = new Dog();
        myAnimal.Speak(); // Output: Dog barks

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

Output:
Dog barks
Cat meows

using System;
using System.Collections.Generic;

interface IShape
{
    double CalculateArea();
}

class Circle : IShape
{
    public double Radius { get; }

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

    public double CalculateArea()
    {
        return Math.PI * Radius * Radius;
    }
}

class Rectangle : IShape
{
    public double Width { get; }
    public double Height { get; }

    public Rectangle(double width, double height)
    {
        Width = width;
        Height = height;
    }

    public double CalculateArea()
    {
        return Width * Height;
    }
}

class Program
{
    static void Main()
    {
        List<IShape> shapes = new List<IShape>
        {
            new Circle(5),
            new Rectangle(4, 6)
        };

        foreach (IShape shape in shapes)
        {
            Console.WriteLine("Area: " + shape.CalculateArea());
        }
        // Output:
        // Area: 78.53981633974483
        // Area: 24
    }
}

Output:
Area: 78.53981633974483
Area: 24

5. The virtual, override, and abstract Keywords

using System;

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

class Triangle : Shape
{
    public double BaseLength { get; }
    public double Height { get; }

    public Triangle(double baseLength, double height)
    {
        BaseLength = baseLength;
        Height = height;
    }

    public override double CalculateArea()
    {
        return 0.5 * BaseLength * Height;
    }
}

class Program
{
    static void Main()
    {
        Shape triangle = new Triangle(5, 10);
        Console.WriteLine("Area of Triangle: " + triangle.CalculateArea()); // Output: Area of Triangle: 25
    }
}

Output:
Area of Triangle: 25

6. Upcasting and Downcasting

using System;

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

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

    public void Fetch()
    {
        Console.WriteLine("Dog fetches the ball");
    }
}

class Program
{
    static void Main()
    {
        // Upcasting
        Animal animal = new Dog();
        animal.Speak(); // Output: Dog barks

        // Downcasting
        Dog dog = (Dog)animal;
        dog.Fetch(); // Output: Dog fetches the ball
    }
}

Output:
Dog barks
Dog fetches the ball

7. Polymorphism with Collections

using System;
using System.Collections.Generic;

abstract class Employee
{
    public string Name { get; set; }
    public abstract void Work();
}

class Manager : Employee
{
    public override void Work()
    {
        Console.WriteLine($"{Name} is managing the team.");
    }
}

class Developer : Employee
{
    public override void Work()
    {
        Console.WriteLine($"{Name} is writing code.");
    }
}

class Designer : Employee
{
    public override void Work()
    {
        Console.WriteLine($"{Name} is designing interfaces.");
    }
}

class Program
{
    static void Main()
    {
        List<Employee> employees = new List<Employee>
        {
            new Manager { Name = "Alice" },
            new Developer { Name = "Bob" },
            new Designer { Name = "Charlie" }
        };

        foreach (Employee employee in employees)
        {
            employee.Work();
        }
        // Output:
        // Alice is managing the team.
        // Bob is writing code.
        // Charlie is designing interfaces.
    }
}

Output:
Alice is managing the team.
Bob is writing code.
Charlie is designing interfaces.

8. Real-World Example: Polymorphism in a Payment System

using System;
using System.Collections.Generic;

abstract class PaymentMethod
{
    public abstract void ProcessPayment(decimal amount);
}

class CreditCard : PaymentMethod
{
    public override void ProcessPayment(decimal amount)
    {
        Console.WriteLine($"Processing credit card payment of {amount:C}");
    }
}

class PayPal : PaymentMethod
{
    public override void ProcessPayment(decimal amount)
    {
        Console.WriteLine($"Processing PayPal payment of {amount:C}");
    }
}

class BankTransfer : PaymentMethod
{
    public override void ProcessPayment(decimal amount)
    {
        Console.WriteLine($"Processing bank transfer of {amount:C}");
    }
}

class Program
{
    static void Main()
    {
        List<PaymentMethod> payments = new List<PaymentMethod>
        {
            new CreditCard(),
            new PayPal(),
            new BankTransfer()
        };

        foreach (PaymentMethod payment in payments)
        {
            payment.ProcessPayment(100m);
        }
        // Output:
        // Processing credit card payment of $100.00
        // Processing PayPal payment of $100.00
        // Processing bank transfer of $100.00
    }
}

Output:
Processing credit card payment of $100.00
Processing PayPal payment of $100.00
Processing bank transfer of $100.00

9. Summary

Key points