Unlock the Power of Method Overloading in C#

What is Method Overloading?

In C#, method overloading is a feature that allows multiple methods in a class to share the same name, as long as they have different parameters. This means that a class can have multiple methods with the same name, but with varying numbers, types, or orders of parameters.

The Magic of Overloaded Methods

Let’s take a closer look at an example of method overloading in action. Suppose we have a class with two methods, both named display(), but with different parameters. The first method takes a single integer parameter, while the second method takes two parameters – an integer and a string.

public class Program
{
    public void display(int num)
    {
        Console.WriteLine("Displaying integer: " + num);
    }

    public void display(int num, string str)
    {
        Console.WriteLine("Displaying integer and string: " + num + ", " + str);
    }
}

Overloading by Changing the Number of Parameters

One way to overload methods is by changing the number of parameters. In our example, we can have two methods with the same name, display(), but with different numbers of parameters.

Program p1 = new Program();

p1.display(100); // calls the method with a single parameter
p1.display(100, 200); // calls the method with two parameters

Output:

• Displaying integer: 100
• Displaying integer and string: 100, 200

Overloading by Changing the Data Types of Parameters

Another way to overload methods is by changing the data types of the parameters. We can have two methods with the same name, display(), but with different data types of parameters.

public class Program
{
    public void display(int num)
    {
        Console.WriteLine("Displaying integer: " + num);
    }

    public void display(string str)
    {
        Console.WriteLine("Displaying string: " + str);
    }
}

Program p1 = new Program();

p1.display(100); // calls the method with an int type parameter
p1.display("Programiz"); // calls the method with a string type parameter

Output:

• Displaying integer: 100
• Displaying string: Programiz

Overloading by Changing the Order of Parameters

We can also overload methods by changing the order of the parameters. In this case, we can have two methods with the same name, display(), but with different orders of parameters.

public class Program
{
    public void display(int num, string str)
    {
        Console.WriteLine("Displaying integer and string: " + num + ", " + str);
    }

    public void display(string str, int num)
    {
        Console.WriteLine("Displaying string and integer: " + str + ", " + num);
    }
}

Program p1 = new Program();

p1.display(100, "Programming"); // calls the method with int and string parameters
p1.display("Programiz", 400); // calls the method with string and int parameters

Output:

• Displaying integer and string: 100, Programming
• Displaying string and integer: Programiz, 400

Key Takeaways

Method overloading is a powerful feature in C# that allows for more flexibility and readability in our code. By changing the number, types, or order of parameters, we can create multiple methods with the same name, making our code more efficient and easier to maintain.

With method overloading, we can:

• Write more concise and expressive code
• Improve code readability and maintainability
• Increase flexibility in our programming approach

By leveraging method overloading, we can take our C# programming skills to the next level and write more efficient, effective, and elegant code.