What is method overloading?

Method overloading is a concept in programming where multiple methods in the same class can have the same name but different parameter lists. This allows you to provide different ways to call a method based on the type or number of arguments passed. The appropriate method to be called is determined at compile time based on the arguments provided.

We can perform method overloading in C# by two ways:
• Method overloading by changing no of parameters
• Method overloading by using different data type of the arguments

Let's illustrate method overloading with a real-time example using a simple calculator class in C#:

using System;

class Calculator
{
    public int Add(int a, int b)
    {
        return a + b;
    }

    public double Add(double a, double b)
    {
        return a + b;
    }

    public string Add(string a, string b)
    {
        return a + b;
    }
}

class Program
{
    static void Main(string[] args)
    {
        Calculator calculator = new Calculator();

        int result1 = calculator.Add(5, 10);
        double result2 = calculator.Add(3.5, 2.8);
        string result3 = calculator.Add("Hello, ", "world!");

        Console.WriteLine("Result 1: " + result1);
        Console.WriteLine("Result 2: " + result2);
        Console.WriteLine("Result 3: " + result3);
    }
}

1. 'Add(int a, int b)' - Adds two integers and returns an integer result.
2. 'Add(double a, double b)' - Adds two doubles and returns a double result.
3. 'Add(string a, string b)' - Concatenates two strings and returns a string result.

When you run the program, you'll see the following output:

Result 1: 15
Result 2: 6.3
Result 3: Hello, world!

Even though all the methods are named 'Add', the appropriate version of the method to be called is determined at compile-time based on the argument types. This demonstrates method overloading, where the same method name is used to provide different behaviors based on the types of arguments.

1. Same Method Name: Method overloading involves creating multiple methods within the same class with the same name.
2. Different Parameters: Overloaded methods must have different parameter lists. This can involve a different number or type of parameters.
3. Compile-Time Resolution: The decision about which overloaded method to call is made by the compiler at compile time, based on the arguments provided.
4. Return Type Not Considered: The return type of the method is not taken into account when determining which overloaded method to call.
5. Access Modifiers: Overloaded methods can have different access modifiers (public, private, protected, etc.), but they must have the same name and compatible parameter lists.
6. Changing Only Return Type Is Not Overloading: Overloading is not determined by just changing the return type of a method. The parameter list must differ.
7. Can Improve Readability: Method overloading can make the code more readable by providing clear and intuitive method names for different variations of functionality.
8. Examples: Overloading is often used for constructors with different parameter sets, mathematical operations (int, double), and type conversions (ToString).
9. Polymorphism Not Involved: Method overloading is not a form of polymorphism. It is a form of compile-time (static) polymorphism, whereas runtime polymorphism involves method overriding in inheritance hierarchies.
10. Best Practices: Overloading should be used sensibly to enhance code clarity and avoid confusion. Overloading with too many variations can make code harder to understand.
11. Documentation: Document your overloaded methods well, explaining their purpose and the differences in parameter sets.
12. Common Naming Convention: Overloaded methods should ideally have names that convey their purpose along with the parameters they accept. This helps other developers understand their functionality.

Remember, method overloading allows you to provide multiple versions of a method with different parameter lists, enhancing the flexibility and usability of your codebase.