Method Overloading in C#

What is Method Overloading in C#?

When you want to implement the feature of polymorphism, it is done with method overloading. In layman term, if we want to use one function for more than one form, we use method overloading. Since C# is OOPs based language, it completely supports polymorphism.

A programmer can use one class multiple times with the same name with different parameters. While using performing polymorphism, two classes or methods could use the same name.

Let’s talk about the various methods of using parameters in the classes and methods of c#.

1. We can overload the method based on several parameters passed. In methods, parameters should be passed as arguments.
2. Two methods can not be defined with the same name with the same type and order of the parameters passed. It would give you an error.
3. Though the compiler’s return type is not considered, two methods can not be declared with the same name, type or signature.

What is the Use of Method Overloading?

When you do not want to declare more than one method for a similar type of method for similar tasks to be performed and want to use the same method in different ways, for example, different inputs, different order, different number of inputs for the same methods, you should use method overloading.

Let’s take a real-life example. We are coding for a calculator where you are provided to code for the sum part of the calculator. All the numbers which the user is entering should be added to each other and return the sum of all the number entered.

There is a restriction. Users can not add more than three numbers in one go.

Here are the steps to do it easily:

1. Declare a method that should sum all the numbers passed in parameters
2. The numbers of parameters passed would do method overloading.
3. The method should return the sum of all the numbers entered.

Syntax

Here is the syntax of method overloading.

//declare the parameters in method
public void method1 (parameter1, parameter2)
{
//some statement
}
public void method1(parameter2, parameter1)
{
//some statement to be executed
}
//in main method pass the parameters while declaring these methods
public static void Main(Strings[] args)
{
class object=new class();
object.method(2, 3)  //value of parameter
object.method(3, 2) //value of parameter by changing the order
}
}

Examples of Method Overloading

Method overloading in C# can be done by changing the below things.

1. You can change the number of parameters passed in the method
2. You can change the type of parameters passed in the method
3. You can change the order of parameters passed in the method.

If the same type of signature and parameters are passed in the same method, it will give you a compilation error. The signature should be different if using the feature of polymorphism or trying to overload a method in C#

Let’s take an example of each.

1. Changing the number of parameters

Code:

using System;
public class methodOverloadfirst
{
//declaring two integers x and y.
public int sum(int x, int y)
{
int result=x+y;
return result;
}
//Let’s add three integers in same method
public int sum(int x, int y, int z)
{
int result=x+y+z;
return result;
}
//Declare main method
public static void Main(String[] args)
{
methodOverloadfirst obj=new methodOverloadfirst();
int result1=obj.sum(2, 3);
Console.WriteLine("The Sum of the two integer value is : " + result1);
int result2=obj.sum(2, 3, 4);
Console.WriteLine("The Sum of the three integer value is : " + result2);
}
}

Output:

2. Changing the Data Types of the parameters

//Our program to show the function of method overloading
//We will change the data type of parameters here.

Code:

using System;
public class methodOverloadfirst
{
//declaring two integers x and y.
public int sum(int x, int y)
{
int result=x+y;
return result;
}
//Let’s add three doubles in same method
public double sum(double x, double y, double z)
{
double result=x+y+z;
return result;
}
//Declare main method
public static void Main(String[] args)
{
methodOverloadfirst obj=new methodOverloadfirst();
int result1=obj.sum(2, 3);
Console.WriteLine("The Sum of the two integer value is : " + result1);
double result2=obj.sum(2.1, 3.2, 4.5);
Console.WriteLine("The Sum of the three double value is : " + result2);
}
}

Output:

3. Changing the Data Types of the parameters.

//Our program to show the function of method overloading
//We will change the data type of parameters here.

Code:

using System;
class methodOverloadfirst
{
//declaring one integer and one String
public void displayinfo(string fname, int empID){
Console.WriteLine("Your name is: " + fname + " , " + "Your Employee ID is: " + empID);
}
//Let’s change the order of the parameters
public void displayinfo(int empID, string fname)
{
Console.WriteLine("Your Employee ID is: " + empID + " , " + "Your name is: " + fname);
}
//Declare main method
public static void Main(String[] args)
{
methodOverloadfirst obj=new methodOverloadfirst();
obj.displayinfo("Kumar", 121);
obj.displayinfo("Anand", 123);
}
}

Output:

Conclusion

Method overloading is an amazing feature of OOPs based concept and could save you from a lot of hassle if you are a programmer. Method overloading is one of the polymorphism features. If used properly, it could keep you from declaring more than one method and declaring it every time for a similar task.

While using this feature is the type of signature. This should be different each time the method is used either by several parameters and order by parameters or by type of parameters shown above in the examples.

Recommended Articles

This is a guide to Method Overloading in C#. Here we discuss the Use of Method Overloading with different examples and outputs in detail. You may also look at the following article to learn more –

1. Destructor in C#
2. Overloading in C#
3. C# Compilers
4. Overloading and Overriding in C#