Polymorphism in C#

Introduction

Polymorphism is a Greek word meaning "one name many forms". In other words, one object has many forms or has one name with multiple functionalities. "Poly" means many and "morph" means forms. Polymorphism provides the ability to class multiple implementations with the same name. It is one principle concept in Object Oriented Programming after encapsulation and inheritance.

Types of Polymorphism

There are basically the following two types of polymorphism in C#:

• Static / Compile Time Polymorphism/ Early Binding.
• Dynamic / Runtime Polymorphism/ late binding.

Static / Compile Time Polymorphism/ Early Binding.

 Method overloading is an example of Static Polymorphism. In Overloading, the method / function has the same name but different signatures. It is also known as Compile Time Polymorphism because the decision of which method is to be called is made at compile time. Overloading is the concept in which method names are the same with a different set of parameters.

Here the compiler checks the number of parameters passed and the type of parameter and make the decision of which method to call and it throw an error if no matching method is found.

In the following example the class has two methods with the same name "Add" but with different input parameters (the first method has three parameters and the second method has two parameters).

1. public class AddData  
2. {  
3.     public int Add(int FirstNumber, int SecondNumber, int ThirdNumber)  
4.     {  
5.         return FirstNumber + SecondNumber + ThirdNumber;  
6.     }  
7.     public int Add(int FirstNumber , int SecondNumber )  
8.     {  
9.         return FirstNumber  + SecondNumber ;  
10.     }  
11. }  
12. class Program  
13. {  
14.     static void Main(string[] args)  
15.     {  
16.         AddData  dataClass = new AddData  ();  
17.         int addThreeParameters = dataClass.Add(45, 34, 67);  
18.         int addTwoParameters = dataClass.Add(23, 34);  
19.     }  
20. }  

• Dynamic / Runtime Polymorphism/ late binding.

     Here, the method name and the method signature (number of parameters and parameter type must be the same and may have a different implementation). Method overriding is an example of dynamic polymorphism.

Method overriding can be done using inheritance. With method overriding it is possible for the base class and derived class to have the same method name and same something. The compiler would not be aware of the method available for overriding the functionality, so the compiler does not throw an error at compile time. The compiler will decide which method to call at runtime and if no method is found then it throws an error.

Programming Example

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace RuntimePolymorphism
{
    class Program
    {
        static void Main(string[] args)
        {
            Chocolate ch = new Chocolate();
            ch.flavor();
            Console.ReadKey();
        }
    }
    class IceCream
    {
        public IceCream()
        {
            Console.WriteLine("Class : Icecream");
        }
        public virtual void flavor()
        {
            Console.WriteLine("IceCream Type : Vanilla");
        }
    }
    class Chocolate : IceCream
    {
        public Chocolate()
        {
            Console.WriteLine("Class : Chocolate");
        }
        public override void flavor()
        {
            Console.WriteLine("IceCream Type : Chocolate");
        }
    }
}

OUTPUT :-  Class : Icecream,Class : Chocolate,IceCream Type : ChocolateThank you  Arjun Walmiki