C# - Polymorphism

Polymorphism in C#

Polymorphism is a core concept in Object-Oriented Programming (OOP) that allows objects to be treated as instances of their base class rather than their actual class. This enables a single interface to represent different underlying forms (data types). In C#, polymorphism is primarily achieved through method overriding and method overloading.

Types of Polymorphism

Compile-time Polymorphism (Method Overloading):

Method overloading allows a class to have multiple methods with the same name but different parameters (type, number, or both). The compiler differentiates these methods based on their signatures.

Runtime Polymorphism (Method Overriding):

Method overriding allows a derived class to provide a specific implementation of a method that is already defined in its base class. The method in the base class must be marked with the virtual or abstract keyword, and the method in the derived class must use the override keyword.

Method Overloading (Compile-time Polymorphism)

Method overloading is the ability to create multiple methods with the same name but with different signatures in the same class.

Example of Method Overloading

public class MathOperations
{
    // Method with one parameter
    public int Add(int a)
    {
        return a + a;
    }

    // Method with two parameters
    public int Add(int a, int b)
    {
        return a + b;
    }

    // Method with three parameters
    public int Add(int a, int b, int c)
    {
        return a + b + c;
    }
}

// Usage
public class Program
{
    public static void Main(string[] args)
    {
        MathOperations math = new MathOperations();
        
        Console.WriteLine(math.Add(5));          // Output: 10
        Console.WriteLine(math.Add(5, 3));       // Output: 8
        Console.WriteLine(math.Add(5, 3, 2));    // Output: 10
    }
}

Method Overriding (Runtime Polymorphism)

Method overriding allows a derived class to provide a specific implementation of a method that is already defined in its base class.

Example of Method Overriding

public class Animal
{
    // Virtual method
    public virtual void MakeSound()
    {
        Console.WriteLine("Animal sound");
    }
}

public class Dog : Animal
{
    // Override method
    public override void MakeSound()
    {
        Console.WriteLine("Bark");
    }
}

public class Cat : Animal
{
    // Override method
    public override void MakeSound()
    {
        Console.WriteLine("Meow");
    }
}

// Usage
public class Program
{
    public static void Main(string[] args)
    {
        Animal myAnimal = new Animal();
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        myAnimal.MakeSound();  // Output: Animal sound
        myDog.MakeSound();     // Output: Bark
        myCat.MakeSound();     // Output: Meow
    }
}

Polymorphism with Interfaces

Interfaces are another way to achieve polymorphism in C#. An interface defines a contract that implementing classes must follow.

public interface IShape
{
    void Draw();
}

public class Circle : IShape
{
    public void Draw()
    {
        Console.WriteLine("Drawing a Circle");
    }
}

public class Rectangle : IShape
{
    public void Draw()
    {
        Console.WriteLine("Drawing a Rectangle");
    }
}

// Usage
public class Program
{
    public static void Main(string[] args)
    {
        IShape shape1 = new Circle();
        IShape shape2 = new Rectangle();

        shape1.Draw();  // Output: Drawing a Circle
        shape2.Draw();  // Output: Drawing a Rectangle
    }
}

Polymorphism with Abstract Classes

Abstract classes can also be used to achieve polymorphism. An abstract class can contain both abstract methods (without implementation) and concrete methods (with implementation).

public abstract class Shape
{
    // Abstract method
    public abstract void Draw();

    // Concrete method
    public void Display()
    {
        Console.WriteLine("Displaying shape");
    }
}

public class Circle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing a Circle");
    }
}

public class Rectangle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing a Rectangle");
    }
}

// Usage
public class Program
{
    public static void Main(string[] args)
    {
        Shape shape1 = new Circle();
        Shape shape2 = new Rectangle();

        shape1.Draw();   // Output: Drawing a Circle
        shape1.Display(); // Output: Displaying shape

        shape2.Draw();   // Output: Drawing a Rectangle
        shape2.Display(); // Output: Displaying shape
    }
}

Benefits of Polymorphism

Code Reusability: Polymorphism allows for code reuse. Methods can be defined in a base class and overridden in derived classes, providing specific implementations as needed.

Maintainability: It is easier to manage and maintain code as new functionalities can be added with minimal changes.

Extensibility: New classes can be introduced with little or no modification to the existing codebase.

Flexibility: It allows objects to be manipulated based on their base class rather than their actual derived class.

Conclusion

Polymorphism in C# is a powerful feature that allows objects to be treated as instances of their base class, facilitating code reuse and flexibility. It is achieved through method overloading (compile-time polymorphism) and method overriding (runtime polymorphism), as well as through the use of interfaces and abstract classes. By leveraging polymorphism, developers can create more maintainable, scalable, and flexible code.