C# is an Object-oriented programming language. C# comes with simplicity, expressiveness and great performance to meet the programmer productivity.
So far, we have seen conversion keywords
. Now, let's study polymorphism, static and dynamic polymorphism in C# in this chapter.
The main objective of this article is to learn about method overloading and method overriding in polymorphism in C# programming
Polymorphism simply means 'many forms'. After encapsulation and inheritance, polymorphism plays a major role in object-oriented programming.
In other words, polymorphism means the states or behaviors of an object such as emotions of a person.
There are two types of polymorphism. They are,
Above diagram shows the brief architecture of polymorphism in object-oriented programming.
In static polymorphism, the decision and response to a method is determined at the compile time. Therefore, it is also known as compile-time polymorphism. Static polymorphism involves static binding or early binding.
As the name indicates that early binding links a method with an object at compile time. Hence, calling of method should be done in compile time only.
Method overloading and operator overloading are the examples of static polymorphism.
Method overloading or function overloading is the concept of having more than one methods in a class with the same name and different parameters.
Compiler automatically calls required method by checking number of parameters and their type which are passed into that method.
If the credentials (number of parameters and type) doesn't matched by any method signatures, then it will give compile time error.
public void MyMethod(int x, int y) // MyMethod with int parameters
Console.WriteLine("Integers = " + x + y);
public void MyMethod(char x, char y) // MyMethod with char parameters
Console.WriteLine("Characters = " + x + y);
public void MyMethod(string x, string y) // MyMethod with string parameters
Console.WriteLine("Strings = " + x + y);
static void Main()
MyClass var = new MyClass();
var.MyMethod(2, 3); // This automatically calls int's method
var.MyMethod('a', 'b'); // This calls char's method
var.MyMethod("Method", "Overloading"); // This automatically calls string's method
In the above example code, we have three functions with the same name (MyMethod
) but different parameters i.e. int
parameters for the first one, chars
for the second and strings
for the third one.
In the Main method, if we instantiate integer values, it automatically goes and calls a method which has int parameters.
And if we give characters, it automatically invokes the method which has char parameters.
Similarly if we instantiate string items, it calls the particular method (MyMethod with string parameters) in that class.
Output of this program will prints the following lines in your console,
In dynamic polymorphism, the decision and response to a method is determined at the run time. Therefore, it is also known as run-time polymorphism. dynamic polymorphism involves late binding.
late binding or dynamic binding is a process of linking method to an object during run time (run-time binding).
Method overriding is an example of dynamic polymorphism.
Method overriding or function overriding is the concept of having duplicated methods in base and derived classes with same name as well as same parameters.
- Only abstract and virtual methods can be overridden.
- We cannot declare an abstract method without an abstract class.
- And we cannot an instance of an abstract class.
- For more information, read abstract and virtual modifiers.
Because of run-time binding, we can point to any
derived class from the
base class object at the run time.
Compiler doesn't participate in here to check whether the method is available or not for overriding functionality. Hence, it doesn't throws any
compile time errors at in this case.
All the decisions are made at the
runtime and we will get
runtime error if there is no method to be called.
public virtual void MyMethod() // Virtual method; Gives runtime error if you remove this method
Console.WriteLine("This is the Base Class");
class DerivedClass : BaseClass
public override void MyMethod() // Overriding virtual method
Console.WriteLine("This is the Derived Class");
static void Main()
BaseClass msg = new BaseClass();
msg.MyMethod(); // This will call the BaseClass method
msg = new DerivedClass();
msg.MyMethod(); // This will call the DerivedClass method
In the above example, we have a virtual
in the BaseClass
which is overridden in the DerivedClass
In the Main method, we created an object which is initially pointed to BaseClass method. Hence it calls that method at the runtime.
Again we pointed the same object to the DerivedClass method in which it calls that method at the runtime.
Output of the above code will prints the following lines in your console,
Now in the above code, remove the MyMethod() in the BaseClass and run again.
This will throw a runtime error like below,
In this article, we have studied about polymorphism and types of polymorphism with examples. Hope you understand.
Thanks for reading.