Static Polymorphism and Overloadings in C#

Polymorphism is one of the main pillar concepts of OOPS after Abstraction, Encapsulation, and Inheritance. Polymorphism provides the ability for the developer to implement different methods with the same name.

Polymorphism can be Static or Dynamic. In one of our previous articles, we have learned about Dynamic Polymorphism. Please read the Dynamic Polymorphism article here. In this article, we will walk through Static Polymorphism and Overloadings.

Watch our videos here

Static Polymorphism (Early Binding)

Static Polymorphism is also known as Compile-Time Polymorphism, Compile-Time Binding, Early Binding, or Static Binding.
In Static Polymorphism, the response to a function is determined at the compile time itself, unlike Dynamic Polymorphism where it is decided at run-time.
The mechanism of linking a method or function with an object during compile time is called early binding or static binding.
Using Static Polymorphism, we can perform different tasks with the same method name by passing the different parameters.
In C#, the Static Polymorphism is achieved by using Overloadings.

If you see the IL Code of the overloaded Sum() method, it is bound at compile-time itself based on the types of parameters instead of run-time:

Overloading

The overloading is one of the common ways to implement Static Polymorphism in C#.
If we create two or more members having the same name but different signatures, it is known as member overloading.
The method signature is defined by the method name and the definitions of the method parameters (only parameter types are considered, and the parameter names are ignored).
The returned type as a result of the method is not a part of its signature. If the returned type was a part of the signature, then the compiler doesn't know which method exactly to call (there is ambiguity).
Method Modifiers (static, virtual, sealed, abstract) and Access Modifiers (public, private, internal, protected, etc) are also not part of the method signature.
At compile-time, the compiler works out which one it is going to call, based on the compile-time types of the arguments and the target of the method call.
Generally overloading is used for convenience, usually with all overloads ending up calling one common "master" method name.

Types of Overloading

There are multiple ways to implement Static Polymorphism in C#. Below are the different ways to implement Overloading in C#:

Method Overloading or Function Overloading
Constructor Overloading
Indexer Overloading
Operator Overloading

Examples

// Author 	:	Tech Point Fundamentals
// Website	: 	www.techpointfunda.com
// Youtube	: 	https://www.youtube.com/c/TechPointFundamentals
// Demo 	: 	Static Polymorphism and Method Overloading

using System;
using System.Linq;

public class Program
{
  public static void Main()
  {
  Polymorphism staticBinding = new Polymorphism();

  // Method Overloading
  Console.WriteLine("******************* Method Overloading *******************\n");

  int sum = staticBinding.Sum(10, 20);
  Console.WriteLine("Sum(10, 20) : " + sum);

  double sumDouble = staticBinding.Sum(15.5, 25.5);
  Console.WriteLine("Sum(15.5, 25.5) : " + sumDouble);

  string concatenate = staticBinding.Sum("Tech Point", "Fundamentals");
  Console.WriteLine("Sum(Tech Point, Fundamentals) : " + concatenate);


  // Constructor Overloading
  Console.WriteLine("\n\n*************** Constructor Overloading ***************\n");

  var emp1 = new Employee();
  var emp2 = new Employee(5);


  // Indexer Overloading
  Console.WriteLine("\n\n******************* Indexer Overloading *******************\n");

  emp2[0] = new Employee { Id = 1, Code = "EMP001", Name = "Employee-1" };
  emp2["EMP002"] = new Employee { Id = 2, Code = "EMP002", Name = "Employee-2" };

  Console.WriteLine("Emp-1 Name : " + emp2[0].Name);
  Console.WriteLine("Emp-2 Name : " + emp2["EMP002"].Name);

  // Operator Overloading
  Console.WriteLine("\n\n******************* Operator Overloading *******************\n");

  ComplexNumber num1 = new ComplexNumber(50);
  ComplexNumber num2 = new ComplexNumber(30);

  ComplexNumber result = num1 + num2;
  result.DisplayResult();

  }
}

 // Method Overloadings
public class Polymorphism
{
  public int Sum(int x, int y)
  {
  return x + y;            
  }

  public double Sum(double x, double y)
  {
  return x + y;
  }

  public string Sum(string x, string y)
  {
  return x + " " + y;
  }
}

// Constructor and Indexer Overloadings
public class Employee
{
  private Employee[] _employee;
  private int count = 0;

  #region Constructor Overloadings

  static Employee()
  {
  Console.WriteLine("Static Constructor is called.");
  }
  public Employee()
  {
  _employee = new Employee[10];
  Console.WriteLine("Default Instance Constructor is called.");
  }
  public Employee(int size)
  {
  _employee = new Employee[size];
  Console.WriteLine("Parameterized Constructor is called : " + size);
  }

  #endregion

  #region Property

  public int Id { get; set; }
  public string Code { get; set; }
  public string Name { get; set; }

  #endregion

  #region Indexer Overloading              

  public Employee this[int index]
  {
  get { return _employee[index];}
  set { _employee[index] = value; ++count; }
  }

  public Employee this[string code]
  {
  get {return _employee.Where(r => r.Code == code).FirstOrDefault();}
  set { _employee[count] = value; }
  }

  #endregion
}

// Operator Overloading
public class ComplexNumber
{
  public int number = 0;

  // Default Constructor
  public ComplexNumber() { }

  // Parameterized Constructor
  public ComplexNumber(int num)
  {
  number = num;
  }

  // Overloading Binary "+" operator for -
  public static ComplexNumber operator +(ComplexNumber num1, ComplexNumber num2)
  {
  ComplexNumber num3 = new ComplexNumber(0);
  num3.number = num1.number - num2.number;
  return num3;
  }

  public void DisplayResult()
  {
  Console.WriteLine("Result : {0}", this.number);
  }
}

Method Overloading (Function Overloading)

Method Overloading is the process of creating multiple methods in a class with the same name but with a different signature.
Creating a method in the derived class with the same name as a method in the base class but a different signature is also known as Method Overloading.
The advantage of method overloading is that it increases the readability of the program as you do not need to use different method names for the same action.
There are some Rules of Overloading which we have to follow while overloading.

Method Overloading Fundamental Rules

Two methods are overloaded only if they have different signatures at compile time. Two method signatures are considered as different only if they have:

Different number of parameters
Different types of parameters
Different order of parameters
Different kinds of parameters (REF, OUT, IN, Dynamic)

Two methods are not considered as overloaded if they are different only in terms of:

Different return types (int, string, double, etc.)
Different access modifiers (private, public, protected, internal, etc.)
Different method modifiers ( static, virtual, sealed, abstract, partial, etc.)
Different reference parameter modifiers (ref, out, in)
Different boxing parameter types (object, dynamic)
Different parameter types (params, optional, mandatory)
Overriding Method and Normal Method (Inheritance Based Overloading)

The compiler does not consider the above cases while differentiating the overloaded method. In all the above cases you will get a compile-time error.

Method Overloading vs Method Overriding

Method Overloading is static polymorphism while Method Overriding is dynamic polymorphism. So Method Overloading executes at compile-time while Method Overriding executes at run-time.
Method Overloading is generally defined in the same class while Method Overriding only is used in inheritance.
For Method Overriding the base class method must be virtual (abstract in abstract class) while it is not required in the case of Method Overloading.
In Method Overriding you can not change the method signature in the derived class while Method Overloading is only possible with different method signatures.
Method Overriding requires forcefully rewriting the method definition with the same signature in the derived class while Method Overloading is more flexible by allowing different signatures for different overloading methods.
The Overriding Method is not considered as an overloaded member of the derived class, while other methods with the same name and different signatures are considered as the overloaded methods.

Please read more about the method overriding here.

Constructor Overloading

A constructor is nothing but a method without any return type which has the same name as the class or struct name. Constructors are called automatically when we create the object of the class.

Constructor Overloading is quite similar to Method Overloading. It is the ability to define Constructors with different parameters. But static constructors cannot be overloaded because parameterized static constructors are not allowed.

Please read more about the constructors and constructor overloading here.

Indexer Overloading

An indexer allows an object to be indexed such as an array. When you define an indexer for a class or structure, this class or structure behaves similar to a virtual array. So you can access the instance of this class or structure using the array access operator ([ ]).

The indexers can return or set a particular value from the current object instance. So, indexers are not defined with any names, but with the "this" keyword, which refers to the current object instance.

Like Methods and Constructors, Indexers can also be overloaded in C#. We can define multiple indexers in a single class or structure.

It is not necessary that the indexes have to be only integers. So the indexer may have different types of parameters or numbers of parameters or both.

Operator Overloading

The concept of overloading a method is also be applied to operators. Operator overloading provides the ability to use the same operator for different purposes.

An operator can be overloaded by defining a function to it. The function of the operator is declared by using the operator keyword.

It is not recommended to overload equality operator (==) on reference types. Please read more here.

Operator Overloading Rules

Only the predefined C# operators can be overloaded.
The operator keyword must be used to declare an operator.
A unary operator has one input parameter.
A binary operator has two input parameters.
The overloaded function can contain both a public and a static modifier.

Non-Overloadable Operators

The Compound Assignment Operators cannot be overloaded. For example (+=, -=, *=, /=, %=) operators cannot be overloaded.
The Cast Operator cannot be overloaded. For example (T) x.
The Array Index Operator cannot be overloaded but indexers can be defined. For example, a[i] cannot be overloaded.
The Conditional Logical Operators cannot be overloaded directly. For Example (&&, ||) operators cannot be overloaded directly.
The Assignment Operator(=), Dot Operator(.), Ternary Operator(? :), Arrow Operator (->) cannot be overloaded.
The as, await, checked, unchecked, default, delegate, is, nameof, new, sizeof, stackalloc, switch, with, typeof operators cannot be overloaded.

Please read more about operator overloading here.

Live Demo

Conclusion

Overloading is a way to achieve the static polymorphism in C#.
The compiler decides which method is going to be called at compile time itself in the static polymorphism.
Overloading is what happens when you have two methods with the same name but different signatures. You can overload methods, constructors, indexers, and operators.
We must have to follow the overloading rules while overloading the members.
In the next article, we will walk through the overloading dilemma and ambiguity.

Sunday, November 14, 2021

Static Polymorphism and Overloadings in C#