Understanding Default Lambda Parameters in C# 12

Lambda expressions are a powerful feature in C# that allows you to write inline functions, often making your code more concise and readable. With the release of C# 12, a new feature called default lambda parameters has been introduced, adding even more flexibility to lambda expressions. In this blog post, we’ll explore what default lambda parameters are, why they are useful, and how you can use them in your projects.

What are Lambda Expressions?

Before diving into default parameters, let’s briefly recap what lambda expressions are. A lambda expression is a shorthand syntax for writing anonymous methods. It is particularly useful in scenarios where you need to pass a function as an argument or use a function in a LINQ query.

Here’s a simple example of a lambda expression:

Func<int, int> square = x => x * x;
Console.WriteLine(square(5)); // Output: 25

In this example, x => x * x is a lambda expression that takes an integer x and returns its square.

Introducing Default Lambda Parameters

In previous versions of C#, lambda expressions did not support default parameters. This limitation has been lifted in C# 12, allowing you to specify default values for parameters in lambda expressions. This can make your code more flexible and reduce the need for overloads or additional helper methods.

Syntax for Default Lambda Parameters

The syntax for default lambda parameters is straightforward. You simply assign a default value to the parameter within the lambda expression, similar to how you would with regular methods.

Here’s an example:

Func<int, int, int> add = (a, b = 10) => a + b;
Console.WriteLine(add(5)); // Output: 15
Console.WriteLine(add(5, 20)); // Output: 25

In this example, b has a default value of 10. When add is called with only one argument, b takes the default value of 10. When called with two arguments, b takes the provided value.

Benefits of Default Lambda Parameters

Default lambda parameters provide several benefits:

1. Code Simplification: They reduce the need for overloads, making your code cleaner and easier to read.
2. Enhanced Flexibility: They allow for more flexible function definitions, accommodating more use cases without additional methods.
3. Improved Maintainability: With fewer overloads or helper methods, your codebase becomes easier to maintain and update.

Practical Examples

Let’s look at some practical examples where default lambda parameters can be particularly useful.

Example 1: Default Values in LINQ Queries

Consider a scenario where you want to filter a list of numbers with an optional threshold:

List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6 };

Func<int, bool> isGreaterThan = (x, threshold = 3) => x > threshold;

var filteredNumbers = numbers.Where(x => isGreaterThan(x)).ToList();
filteredNumbers.ForEach(Console.WriteLine); // Output: 4, 5, 6

In this example, isGreaterThan has a default threshold value of 3. You can easily change the threshold if needed:

filteredNumbers = numbers.Where(x => isGreaterThan(x, 5)).ToList();
filteredNumbers.ForEach(Console.WriteLine); // Output: 6

Example 2: Configurable Event Handlers

Default lambda parameters can be useful in event handling scenarios. Suppose you have an event handler that logs messages with an optional severity level:

Action<string, string> logMessage = (message, level = "INFO") =>
{
    Console.WriteLine($"[{level}] {message}");
};

logMessage("Application started"); // Output: [INFO] Application started
logMessage("An error occurred", "ERROR"); // Output: [ERROR] An error occurred

In this example, the logMessage lambda has a default severity level of INFO, making it easy to log messages with different levels of severity without needing multiple methods.

Conclusion

Default lambda parameters in C# 12 bring a new level of flexibility and simplicity to lambda expressions. They allow you to define default values for parameters, reducing the need for overloads and making your code more concise and maintainable. As you continue to explore C# 12, consider incorporating default lambda parameters into your projects to take advantage of these benefits.

Key Takeaways

• Default lambda parameters simplify code and enhance flexibility.
• They reduce the need for overloads and helper methods.
• Practical applications include LINQ queries and configurable event handlers.

By understanding and utilizing default lambda parameters, you can write more efficient and maintainable C# code.