Polymorphism:

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 a class to have multiple implementations
with the same name. It is one of the core principles of Object Oriented Programming after
encapsulation and inheritance. In this article, you'll learn what polymorphism is, how it works,
and how to implement polymorphism in C#.

Types of Polymorphism

There are two types of polymorphism in C#:

 Static / Compile Time Polymorphism.

 Dynamic / Runtime Polymorphism.

Static or Compile Time Polymorphism

It is also known as Early Binding. Method overloading is an example of Static

Polymorphism. In overloading, the method / function has a 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 C# 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, a 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 TestData

2. {
3. public int Add(int a, int b, int c)
4. {
5. return a + b + c;
6. }
7. public int Add(int a, int b)
8. {
9. return a + b;
10. }
11. }
12. class Program
13. {
14. static void Main(string[] args)
15. {
16. TestData dataClass = new TestData();
17. int add2 = dataClass.Add(45, 34, 67);
18. int add1 = dataClass.Add(23, 34);
19. }
20. }

Method Overloading
Method Overloading is a type of polymorphism. It has several names like “Compile Time
Polymorphism” or “Static Polymorphism” and sometimes it is called “Early Binding”.

Method Overloading means creating multiple methods in a class with same names but different
signatures (Parameters). It permits a class, struct, or interface to declare multiple methods with
the same name with unique signatures.
Compiler automatically calls required method to check number of parameters and their type
which are passed into that method.
using System;
namespace DemoCsharp
{
class Program
{
public int Add(int num1, int num2)
{
return (num1 + num2);
}

public int Add(int num1, int num2, int num3)

{
return (num1 + num2 + num3);
}
public float Add(float num1, float num2)
{
return (num1 + num2);
}
public string Add(string value1, string value2)
{
return (value1 + " " + value2);
}
static void Main(string[] args)
{
Program objProgram = new Program();
Console.WriteLine("Add with two int parameter :" + ob
jProgram.Add(3, 2));
Console.WriteLine("Add with three int parameter :" +
objProgram.Add(3, 2, 8));
Console.WriteLine("Add with two float parameter :" +
objProgram.Add(3 f, 22 f));
Console.WriteLine("Add with two string parameter :" +
objProgram.Add("hello", "world"));
Console.ReadLine();
}
}
}
Note: Changing the return type of method does not make the method overloaded. You
cannot create method overloaded vary only by return type.
Dynamic / Runtime Polymorphism

Dynamic / runtime polymorphism is also known as 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.

1. public class Drawing

2. {
3. public virtual double Area()
4. {
5. return 0;
6. }
7. }
8.
9. public class Circle : Drawing
10. {
11. public double Radius { get; set; }
12. public Circle()
13. {
14. Radius = 5;
15. }
16. public override double Area()
17. {
18. return (3.14) * Math.Pow(Radius, 2);
19. }
20. }
21.
22. public class Square : Drawing
23. {
24. public double Length { get; set; }
25. public Square()
26. {
27. Length = 6;
28. }
29. public override double Area()
30. {
31. return Math.Pow(Length, 2);
32. }
33. }
34.
35. public class Rectangle : Drawing
36. {
37. public double Height { get; set; }
38. public double Width { get; set; }
39. public Rectangle()
40. {
41. Height = 5.3;
42. Width = 3.4;
43. }
44. public override double Area()
45. {
46. return Height * Width;
47. }
48. }
49.
50. class Program
51. {
52. static void Main(string[] args)
53. {
54.
55. Drawing circle = new Circle();
56. Console.WriteLine("Area :" + circle.Area());
57.
58. Drawing square = new Square();
59. Console.WriteLine("Area :" + square.Area());
60.
61. Drawing rectangle = new Rectangle();
62. Console.WriteLine("Area :" + rectangle.Area());
63. }
64. }
The compiler requires an Area() method and it compiles successfully but the right version of the
Area() method is not being determined at compile time but determined at runtime. Finally the
overriding methods must have the same name and signature (number of parameters and type),
as the virtual or abstract method defined in the base class method and that it is overriding in the
derived class.

A method or function of the base class is available to the child (derived) class without the use of
the "overriding" keyword. The compiler hides the function or method of the base class.
 C# - Operator Overloading
You can redefine or overload most of the built-in operators available in C#.
Thus a programmer can use operators with user-defined types as well.
Overloaded operators are functions with special names the
keyword operator followed by the symbol for the operator being defined.
similar to any other function, an overloaded operator has a return type and a
parameter list.

For example, go through the following function −

public static Box operator+ (Box b, Box c) {

Box box = new Box();
box.length = b.length + c.length;
box.breadth = b.breadth + c.breadth;
box.height = b.height + c.height;
return box;
}

The above function implements the addition operator (+) for a user-defined
class Box. It adds the attributes of two Box objects and returns the resultant
Box object.

Implementing the Operator Overloading

The following program shows the complete implementation −

Live Demo
using System;

namespace OperatorOvlApplication {
class Box {
private double length; // Length of a box
private double breadth; // Breadth of a box
private double height; // Height of a box

public double getVolume() {

return length * breadth * height;
}
public void setLength( double len ) {
length = len;
}
public void setBreadth( double bre ) {
breadth = bre;
 }
public void setHeight( double hei ) {
height = hei;
}

// Overload + operator to add two Box objects.

public static Box operator+ (Box b, Box c) {
Box box = new Box();
box.length = b.length + c.length;
box.breadth = b.breadth + c.breadth;
box.height = b.height + c.height;
return box;
}
}
class Tester {
static void Main(string[] args) {
Box Box1 = new Box(); // Declare Box1 of type Box
Box Box2 = new Box(); // Declare Box2 of type Box
Box Box3 = new Box(); // Declare Box3 of type Box
double volume = 0.0; // Store the volume of a box
here

// box 1 specification
Box1.setLength(6.0);
Box1.setBreadth(7.0);
Box1.setHeight(5.0);

// box 2 specification
Box2.setLength(12.0);
Box2.setBreadth(13.0);
Box2.setHeight(10.0);

// volume of box 1
volume = Box1.getVolume();
Console.WriteLine("Volume of Box1 : {0}", volume);

// volume of box 2
volume = Box2.getVolume();
Console.WriteLine("Volume of Box2 : {0}", volume);

// Add two object as follows:

Box3 = Box1 + Box2;

// volume of box 3
volume = Box3.getVolume();
Console.WriteLine("Volume of Box3 : {0}", volume);
Console.ReadKey();
 }
}
}

When the above code is compiled and executed, it produces the following
result −

Volume of Box1 : 210

Volume of Box2 : 1560
Volume of Box3 : 5400

Overloadable and Non-Overloadable Operators

The following table describes the overload ability of the operators in C# −

Sr.No. Operators & Description

+, -, !, ~, ++, --
1
These unary operators take one operand and can be overloaded.

+, -, *, /, %
2
These binary operators take one operand and can be overloaded.

==, !=, <, >, <=, >=

3
The comparison operators can be overloaded.

&&, ||
4
The conditional logical operators cannot be overloaded directly.

+=, -=, *=, /=, %=

5
The assignment operators cannot be overloaded.

=, ., ?:, ->, new, is, sizeof, typeof

6
These operators cannot be overloaded.

Learn C# in-depth with real-world projects through our C# certification

course. Enroll and become a certified expert to boost your career.

Example
In the light of the above discussions, let us extend the preceding example,
and overload few more operators −

Live Demo
using System;

namespace OperatorOvlApplication {
class Box {
private double length; // Length of a box
private double breadth; // Breadth of a box
private double height; // Height of a box

public double getVolume() {

return length * breadth * height;
}
public void setLength( double len ) {
length = len;
}
public void setBreadth( double bre ) {
breadth = bre;
}
public void setHeight( double hei ) {
height = hei;
}

// Overload + operator to add two Box objects.

public static Box operator+ (Box b, Box c) {
Box box = new Box();
box.length = b.length + c.length;
box.breadth = b.breadth + c.breadth;
box.height = b.height + c.height;
return box;
}
public static bool operator == (Box lhs, Box rhs) {
bool status = false;
if (lhs.length == rhs.length && lhs.height == rhs.height
&& lhs.breadth == rhs.breadth) {

status = true;
}
return status;
}
public static bool operator !=(Box lhs, Box rhs) {
bool status = false;

if (lhs.length != rhs.length || lhs.height != rhs.height

||
 lhs.breadth != rhs.breadth) {

status = true;
}
return status;
}
public static bool operator <(Box lhs, Box rhs) {
bool status = false;

if (lhs.length < rhs.length && lhs.height < rhs.height

&& lhs.breadth < rhs.breadth) {

status = true;
}
return status;
}
public static bool operator >(Box lhs, Box rhs) {
bool status = false;

if (lhs.length > rhs.length && lhs.height >

rhs.height && lhs.breadth > rhs.breadth) {

status = true;
}
return status;
}
public static bool operator <=(Box lhs, Box rhs) {
bool status = false;

if (lhs.length <= rhs.length && lhs.height

<= rhs.height && lhs.breadth <= rhs.breadth) {

status = true;
}
return status;
}
public static bool operator >=(Box lhs, Box rhs) {
bool status = false;

if (lhs.length >= rhs.length && lhs.height

>= rhs.height && lhs.breadth >= rhs.breadth) {

status = true;
}
return status;
}
public override string ToString() {
 return String.Format("({0}, {1}, {2})", length, breadth,
height);
}
}
class Tester {
static void Main(string[] args) {
Box Box1 = new Box(); // Declare Box1 of type Box
Box Box2 = new Box(); // Declare Box2 of type Box
Box Box3 = new Box(); // Declare Box3 of type Box
Box Box4 = new Box();
double volume = 0.0; // Store the volume of a box
here

// box 1 specification
Box1.setLength(6.0);
Box1.setBreadth(7.0);
Box1.setHeight(5.0);

// box 2 specification
Box2.setLength(12.0);
Box2.setBreadth(13.0);
Box2.setHeight(10.0);

//displaying the Boxes using the overloaded ToString():

Console.WriteLine("Box 1: {0}", Box1.ToString());
Console.WriteLine("Box 2: {0}", Box2.ToString());

// volume of box 1
volume = Box1.getVolume();
Console.WriteLine("Volume of Box1 : {0}", volume);

// volume of box 2
volume = Box2.getVolume();
Console.WriteLine("Volume of Box2 : {0}", volume);

// Add two object as follows:

Box3 = Box1 + Box2;
Console.WriteLine("Box 3: {0}", Box3.ToString());

// volume of box 3
volume = Box3.getVolume();
Console.WriteLine("Volume of Box3 : {0}", volume);

//comparing the boxes

if (Box1 > Box2)
Console.WriteLine("Box1 is greater than Box2");
else
 Console.WriteLine("Box1 is not greater than Box2");

if (Box1 < Box2)

Console.WriteLine("Box1 is less than Box2");
else
Console.WriteLine("Box1 is not less than Box2");

if (Box1 >= Box2)

Console.WriteLine("Box1 is greater or equal to
Box2");
else
Console.WriteLine("Box1 is not greater or equal to
Box2");

if (Box1 <= Box2)

Console.WriteLine("Box1 is less or equal to Box2");
else
Console.WriteLine("Box1 is not less or equal to
Box2");

if (Box1 != Box2)
Console.WriteLine("Box1 is not equal to Box2");
else
Console.WriteLine("Box1 is not greater or equal to
Box2");
Box4 = Box3;

if (Box3 == Box4)
Console.WriteLine("Box3 is equal to Box4");
else
Console.WriteLine("Box3 is not equal to Box4");

Console.ReadKey();
}
}
}

When the above code is compiled and executed, it produces the following
result −

Box 1: (6, 7, 5)
Box 2: (12, 13, 10)
Volume of Box1 : 210
Volume of Box2 : 1560
Box 3: (18, 20, 15)
Volume of Box3 : 5400
Box1 is not greater than Box2
Box1 is less than Box2
Box1 is not greater or equal to Box2
Box1 is less or equal to Box2
Box1 is not equal to Box2
Box3 is equal to Box4