Polymorphism Concept in Object-Oriented Programming

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

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

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

        // Calls the first Add method
        int result1 = calculator.Add(5, 10);

        // Calls the second Add method
        double result2 = calculator.Add(2.5, 3.5, 4.0);

        Console.WriteLine($"Result1: {result1}");
        Console.WriteLine($"Result2: {result2}");
    }
}

Run-time polymorphism

Run-time polymorphism, also known as dynamic polymorphism, is when the method or operator to invoke is determined at run time based on the type of the object. This can be done by using inheritance and virtual methods. Inheritance is when you create a new class from an existing class and inherit its members. Virtual methods are methods that can be overridden by derived classes to provide different implementations. For example, you can have a virtual method called Draw() in a base class called Shape, and override it in derived classes such as Circle, Rectangle, and Triangle.

using System;

// base class
class Shape
{
    // virtual method
    public virtual void Draw()
    {
        Console.WriteLine("Drawing a shape");
    }
}

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

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

// derived class
class Triangle : Shape
{
    // override method
    public override void Draw()
    {
        Console.WriteLine("Drawing a triangle");
    }
}

class Program
{
    static void Main(string[] args)
    {
        // create an array of Shape objects
        Shape[] shapes = new Shape[4];
        shapes[0] = new Shape();
        shapes[1] = new Circle();
        shapes[2] = new Rectangle();
        shapes[3] = new Triangle();

        // loop through the array and call the Draw method
        foreach (Shape shape in shapes)
        {
            shape.Draw();
        }
    }
}

Here is an example of polymorphism using inheritance and virtual methods in C#.

Drawing a shape

Drawing a circle

Drawing a rectangle

Drawing a triangle

Polymorphism is deeply ingrained within the .NET Framework. Here's an example demonstrating polymorphism using the Stream class and its derived classes.

using System;
using System.IO;

class Program
{
    static void Main(string[] args)
    {
        // Create a FileStream object, but assign it to a Stream variable
        Stream stream = new FileStream("example.txt", FileMode.Open);

        // Read from the stream
        byte[] buffer = new byte[1024];
        int bytesRead = stream.Read(buffer, 0, buffer.Length);

        // Convert the bytes read to string and display
        Console.WriteLine("Data read from the file:");
        Console.WriteLine(Encoding.UTF8.GetString(buffer, 0, bytesRead));

        // Close the stream
        stream.Close();
    }
}

In this example, we are using polymorphism through the Stream class and its derived class FileStream. We declare a Stream variable and instantiate it with a FileStream object. This is possible because FileStream inherits from Stream, allowing us to treat a FileStream object as a Stream object. Later, we use the Read method of the Stream class to read data from the file. At runtime, the Read method behaves differently based on the actual type of the object (FileStream in this case), demonstrating polymorphic behavior.

Let's assume "example.txt" contains the following text.

"Hello, this is an example file for demonstrating polymorphism in .NET."

Then the output of the program will be:

Data read from the file:

"Hello, this is an example file for demonstrating polymorphism in .NET."

Summary

Polymorphism means one name multiple forms or one function name doing different thing as per context (i.e. number of parameters or type of parameters), types of polymorphism are compile time polymorphism and runtime polymorphism. Compile time polymorphism or early binding is achieved by doing function overloading and operator overloading. Runtime polymorphsim is achieved using function overriding, base class with virtual function and derived class overriding it.