C# Polymorphism

Last modified on: October 19, 2024

<h3>C# Polymorphism: An In-Depth Guide</h3>
<p>Polymorphism is one of the core concepts of object-oriented programming in C#. It allows objects of different classes to be treated as objects of a common base class. The term "polymorphism" means "many forms," and in C#, it enables methods to do different things based on the object that it is acting upon. This guide will cover the two types of polymorphism in C#: compile-time (or static) polymorphism and runtime (or dynamic) polymorphism.</p>
<hr />
<h3>1. <strong>What is Polymorphism?</strong></h3>
<p>Polymorphism allows methods to have the same name but behave differently based on the context in which they are called. This is achieved through method overloading (compile-time polymorphism) and method overriding (runtime polymorphism).</p>
<hr />
<h3>2. <strong>Types of Polymorphism</strong></h3>
<p>C# supports two main types of polymorphism:</p>
<ol>
<li><strong>Compile-Time Polymorphism</strong>: Resolved during compile time, typically through method overloading and operator overloading.</li>
<li><strong>Runtime Polymorphism</strong>: Resolved during runtime, primarily through method overriding.</li>
</ol>
<hr />
<h3>3. <strong>Compile-Time Polymorphism</strong></h3>
<p>Compile-time polymorphism is achieved through method overloading and operator overloading.</p>
<h4>a. <strong>Method Overloading</strong></h4>
<p>Method overloading allows multiple methods in the same class to have the same name with different parameters (type, number, or both).</p>
<h5>Example: Method Overloading</h5>
<pre class="language-csharp"><code>public class MathOperations
{
    // Method to add two integers
    public int Add(int a, int b)
    {
        return a + b;
    }

// Overloaded method to add three integers
    public int Add(int a, int b, int c)
    {
        return a + b + c;
    }

// Overloaded method to add two doubles
    public double Add(double a, double b)
    {
        return a + b;
    }
}

// Using method overloading
MathOperations math = new MathOperations();
Console.WriteLine(math.Add(5, 10));         // Output: 15
Console.WriteLine(math.Add(5, 10, 15));     // Output: 30
Console.WriteLine(math.Add(5.5, 10.5));     // Output: 16
</code></pre>
<p>In this example, the <code>Add</code> method is overloaded to handle different types and numbers of parameters.</p>
<h4>b. <strong>Operator Overloading</strong></h4>
<p>Operator overloading allows you to define the behavior of operators for user-defined types.</p>
<h5>Example: Operator Overloading</h5>
<pre class="language-csharp"><code>public class Complex
{
    public double Real { get; set; }
    public double Imaginary { get; set; }

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

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

// Using operator overloading
Complex c1 = new Complex(1.5, 2.5);
Complex c2 = new Complex(3.0, 4.0);
Complex result = c1 + c2; // Calls the overloaded '+' operator
Console.WriteLine($"Result: {result.Real} + {result.Imaginary}i"); // Output: Result: 4.5 + 6.5i
</code></pre>
<p>In this example, the <code>+</code> operator is overloaded to add two <code>Complex</code> objects.</p>
<hr />
<h3>4. <strong>Runtime Polymorphism</strong></h3>
<p>Runtime polymorphism is achieved through method overriding, where a derived class provides a specific implementation of a method that is already defined in its base class.</p>
<h4>Example: Method Overriding</h4>
<pre class="language-csharp"><code>public class Animal // Base class
{
    public virtual void MakeSound() // Virtual method
    {
        Console.WriteLine("Animal sound");
    }
}

public class Dog : Animal // Derived class
{
    public override void MakeSound() // Overriding method
    {
        Console.WriteLine("Barking...");
    }
}

public class Cat : Animal // Derived class
{
    public override void MakeSound() // Overriding method
    {
        Console.WriteLine("Meowing...");
    }
}

// Using runtime polymorphism
Animal myAnimal;

myAnimal = new Dog();
myAnimal.MakeSound(); // Output: Barking...

myAnimal = new Cat();
myAnimal.MakeSound(); // Output: Meowing...
</code></pre>
<p>In this example, the <code>MakeSound</code> method is overridden in both the <code>Dog</code> and <code>Cat</code> classes. At runtime, the appropriate method is called based on the object type.</p>
<hr />
<h3>5. <strong>Benefits of Polymorphism</strong></h3>
<ul>
<li><strong>Code Reusability</strong>: Polymorphism allows the same method to work with different data types, reducing code redundancy.</li>
<li><strong>Flexibility and Maintainability</strong>: Code is easier to maintain and extend, as new classes can be added without altering existing code.</li>
<li><strong>Improved Readability</strong>: Polymorphism makes code more intuitive, as it uses the same method names for similar operations across different classes.</li>
</ul>
<hr />
<h3>6. <strong>Polymorphism with Interfaces</strong></h3>
<p>C# allows polymorphism through interfaces, enabling different classes to implement the same interface and provide their unique behavior.</p>
<h4>Example: Polymorphism with Interfaces</h4>
<pre class="language-csharp"><code>public interface IShape
{
    double Area();
}

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

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

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

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

// Using polymorphism with interfaces
IShape myShape;

myShape = new Rectangle { Width = 5, Height = 10 };
Console.WriteLine($"Rectangle Area: {myShape.Area()}"); // Output: Rectangle Area: 50

myShape = new Circle { Radius = 7 };
Console.WriteLine($"Circle Area: {myShape.Area()}"); // Output: Circle Area: 153.93804002589985
</code></pre>
<p>In this example, both <code>Rectangle</code> and <code>Circle</code> implement the <code>IShape</code> interface, providing their own implementations of the <code>Area</code> method.</p>
<hr />
<h3>Conclusion</h3>
<p>Polymorphism is a powerful feature in C# that enhances the flexibility and maintainability of code. By allowing methods to be used in multiple forms, it promotes code reuse and enables developers to write more intuitive and extensible applications.</p>

Web Technology View More