Default Parameters and Named Parameters in C#

Introduction

In C#, methods can have **default parameters**, which allow you to specify default values for method parameters, reducing the need for method overloading. You can also use **named parameters**, which allow you to pass arguments by specifying their names, making the method calls more readable and flexible.

Default Parameters

Default parameters allow you to provide a **default value** for a parameter. If no value is passed, the default value is used. This feature simplifies method calls and reduces unnecessary overloads.

Example: Using Default Parameters

void Greet(string name = "Guest")
{
    Console.WriteLine("Hello, " + name);
}

Greet();       // Output: Hello, Guest
Greet("John"); // Output: Hello, John
        

Here, the method Greet has a **default parameter** name with a default value of "Guest". If no argument is passed, "Guest" is used.

Named Parameters

Named parameters allow arguments to be passed to a method by explicitly specifying their **parameter names**. This improves readability and flexibility, especially when dealing with methods that have many parameters.

Example: Using Named Parameters

void OrderPizza(string size, bool cheese, bool pepperoni)
{
    Console.WriteLine($"Ordered a {size} pizza with cheese: {cheese}, pepperoni: {pepperoni}");
}

// Using Named Parameters
OrderPizza(size: "Large", pepperoni: true, cheese: false);

// Output: Ordered a Large pizza with cheese: False, pepperoni: True
        

In this example, OrderPizza is called with **named parameters**, which allows passing arguments **in any order**.

Combining Default and Named Parameters

You can **combine default and named parameters** to make method calls more readable and flexible.

Example: Using Default and Named Parameters

void BookTicket(string destination = "New York", string seatType = "Economy", bool meals = true)
{
    Console.WriteLine($"Booking to {destination}, Seat: {seatType}, Meals: {meals}");
}

// Using Named Parameter with Default Values
BookTicket(meals: false);

// Output: Booking to New York, Seat: Economy, Meals: False
        

In this example, the method BookTicket has **default parameters**, and we override only the meals parameter. The default values for destination and seatType remain unchanged.

Real-World Use Case

Consider a **report generator** where different parameters may or may not be required. Default parameters help to reduce code repetition.

Example: Generating a Report

void GenerateReport(string reportType = "Summary", string format = "PDF", bool includeCharts = true)
{
    Console.WriteLine($"Generating {reportType} report in {format} format. Charts included: {includeCharts}");
}

// Calling the method with default parameters
GenerateReport();

// Using Named Parameters
GenerateReport(format: "Excel", includeCharts: false);

// Output:
// Generating Summary report in PDF format. Charts included: True
// Generating Summary report in Excel format. Charts included: False
        

This example demonstrates how **default parameters** provide flexibility by reducing method overloads, and **named parameters** improve readability.

Performance Considerations

• Default Parameters improve **code maintainability** and **reduce method overloading**.
• Named Parameters enhance **readability** and reduce **ambiguity** in method calls.
• For **optional parameters**, default values are stored **at compile-time**, meaning changes in method signatures require recompilation of dependent code.

Key Points to Remember

• Default parameters allow you to **set default values** for method parameters.
• Named parameters allow you to specify **arguments in any order**.
• Combining **default and named parameters** improves flexibility and readability.
• Default parameters are **evaluated at compile-time**, while named parameters improve **clarity in function calls**.