Method Overloading in C#

What is Method Overloading in C#?

Method Overloading is a feature in C# that allows multiple methods in the same class to have the same name but different parameters. It helps improve code readability and reusability.

Key Features of Method Overloading

• Allows multiple methods with the same name but different parameters.
• Can differentiate methods by number, type, or order of parameters.
• Enhances code readability and maintainability.
• Supports compile-time polymorphism.

Example of Method Overloading

The following example demonstrates how method overloading works.

Example of Method Overloading:

public class Calculator
{
    // Method with two integer parameters
    public int Add(int a, int b)
    {
        return a + b;
    }

    // Overloaded method with three integer parameters
    public int Add(int a, int b, int c)
    {
        return a + b + c;
    }

    // Overloaded method with double parameters
    public double Add(double a, double b)
    {
        return a + b;
    }
}

// Usage
Calculator calc = new Calculator();
Console.WriteLine(calc.Add(5, 10));         // Output: 15
Console.WriteLine(calc.Add(5, 10, 15));     // Output: 30
Console.WriteLine(calc.Add(5.5, 2.3));      // Output: 7.8
        

In this example, the Add method is overloaded with different numbers and types of parameters.

Method Overloading with Different Parameter Order

Overloaded methods can also differ by the order of parameters.

Example of Parameter Order in Method Overloading:

public class Display
{
    // Method with string and int parameters
    public void Show(string message, int number)
    {
        Console.WriteLine($"{message}: {number}");
    }

    // Overloaded method with reversed parameter order
    public void Show(int number, string message)
    {
        Console.WriteLine($"{number} - {message}");
    }
}

// Usage
Display display = new Display();
display.Show("Age", 25);   // Output: Age: 25
display.Show(100, "Score"); // Output: 100 - Score
        

In this example, both methods have the same name but differ in the order of their parameters.

Rules for Method Overloading

• Methods must have the same name but different parameters.
• Methods cannot be overloaded by return type alone.
• Methods must have different numbers, types, or orders of parameters.
• Overloading helps in creating multiple versions of a method for different use cases.

Method Overloading vs. Method Overriding

Benefits of Method Overloading

• Increases code flexibility by allowing different method versions.
• Reduces complexity by using a single method name for related functionalities.
• Enhances readability and maintainability.
• Improves performance through compile-time binding.