Method Overloading in .NET Fundamentals

Method overloading refers to the practice of writing multiple methods within the same scope that share the exact same name but possess different signatures.
The fundamental concept relies on having $1$ method name associated with $N$ distinct signatures.
Under the hood, method overloading carries a $0$ runtime cost because the resolution of which method to call is determined entirely by the compiler during the compilation process.

Overloading allows a class to define multiple implementations of a function under a single name, provided the parameter list (signature) is distinct in a way the compiler can identify.
Consider an example using a class named Calculator:
- public int Add(int a, int b) => a + b; defines an addition method for two integers.
- public double Add(double a, double b) => a + b; defines an addition method for two doubles.
- public int Add(int a, int b, int c) => a + b + c; defines an addition method for three integers.

The compiler distinguishes between overloads based on several specific criteria:
- Parameter Count: Overloads may take a different number of parameters (e.g., adding $2$ numbers versus adding $3$ numbers).
- Parameter Type: Overloads may take parameters of different data types (e.g., int versus double).
- Parameter Order: A different arrangement of differing types qualifies as a unique signature (e.g., a method accepting an int then a string is distinct from one accepting a string then an int).
Crucially, the return type alone cannot be used to distinguish overloads. Defining two methods with the same parameter list but different return types will result in a compile-time error.

Overload resolution is the process by which the compiler chooses the correct method implementation at compile time based on the arguments provided at the call site. The process involves three distinct stages:
1. Collect Candidates: The compiler identifies and gathers every method named Add (or the relevant method name) that is accessible from the specific location of the call.
2. Filter Applicable: The compiler narrows the list to only those overloads where the parameters can be satisfied by the arguments supplied in the code.
3. Pick the Best Match: From the remaining candidates, the compiler selects the most specific overload that requires the fewest type conversions. If the compiler cannot determine a single "best" match (a tie), it generates a compile-time error.
Resolution Examples:
- Invoking calc.Add( $2$ , $3$ ) results in the compiler selecting the Add(int, int) signature.
- Invoking calc.Add( $2.5$ , $3.5$ ) results in the compiler selecting the Add(double, double) signature.

Cleaner API Surface: Overloading provides a more intuitive experience by allowing a single name to represent an action, rather than cluttering the API with names like AddInts, AddDoubles, or AddThree.
Flexible Call Sites: Callers have the flexibility to pass whatever data types they naturally have available, and the language infrastructure automatically directs those arguments to the appropriate logic.
Compile-time Safety: Because resolution is handled before the application runs, any mismatches in types or arguments are caught early in the development cycle, preventing runtime failures.

Maintain Behavioral Consistency: All overloads share a name and should therefore perform conceptually identical tasks. Developers should avoid using the same name for methods that perform unrelated operations.
Avoid Ambiguity: It is best practice to avoid creating overloads that rely on complex or implicit type conversions to be distinguished, as this can make the code difficult to reason about for both the compiler and other developers.
Priority for Optional Parameters: For simple scenarios involving default values, it is often preferred to use optional parameters rather than creating multiple near-duplicate overloads.