Meta Description: Learn how to master optional parameters, named arguments, and expression-bodied syntax in C#. This guide provides clear examples to help you write more flexible and readable methods

In C#, working with method parameters opens up a variety of options for making your code more flexible and readable. In this article, we'll dive into three key features that can simplify how you define and invoke methods: optional parameters, named arguments, and expression-bodied syntax.

1. Optional Parameters

Optional parameters allow you to provide default values for method parameters. When calling a method, you can omit optional parameters, and their default values will be used. This can make your methods more flexible without requiring overloads.

How do they work?

When defining a method, you can assign default values to parameters. These become optional, meaning that the caller can either provide a value or skip them, in which case the default value is used.

public double CalculateTotalPrice(double pricePerItem, int quantity, double discount = 0)
{
    double total = (pricePerItem * quantity) - discount;
    return total;
}

In the example above, the discount parameter has a default value of 0. When calling this method, you can either provide all three parameters or omit the discount.

// Calling with all parameters
double totalPrice = CalculateTotalPrice(50, 3, 10);

// Calling with only two parameters (discount will default to 0)
double totalPriceWithoutDiscount = CalculateTotalPrice(50, 3);

A critical rule to remember is that optional parameters must be placed after all required parameters.

2. Named Arguments

Named arguments let you specify arguments by their parameter names, allowing you to pass them in any order. This can improve readability, especially when working with methods that have multiple parameters or parameters of the same type.

Example:

public double CalculateTotalPrice(double pricePerItem, int quantity, double discount = 0)
{
    double total = (pricePerItem * quantity) - discount;
    return total;
}

// Named arguments allow you to pass parameters in any order:
double totalPriceWithNamedArguments = CalculateTotalPrice(quantity: 3, pricePerItem: 50, discount: 10);

This flexibility is particularly useful when a method has many parameters, and you want to make it clear what each argument refers to.

3. Expression-Bodied Syntax

Expression-bodied syntax is a shorthand for writing concise methods and properties in C#. It reduces boilerplate by using the => operator to define simple methods, making your code more concise and readable.

Example:

// Regular method
public double CalculateDiscountedPrice(double pricePerItem, int quantity, double discount) 
{
    return (pricePerItem * quantity) - discount;
}

// Expression-bodied method
public double CalculateDiscountedPrice(double pricePerItem, int quantity, double discount) 
    => (pricePerItem * quantity) - discount;

By using expression-bodied syntax, you can make short methods even more compact, which is useful for methods that consist of a single expression.

Conclusion

In this article, we explored three useful features for method parameters in C#: optional parameters, named arguments, and expression-bodied syntax. These features can greatly enhance the flexibility and readability of your code by allowing you to define methods that are easier to use and maintain.

By incorporating these techniques, you can write methods that are both powerful and easy to invoke, improving the overall design of your applications.