Introduction

C# 12 adds another gem to this collection: default lambda parameters. This game-changing feature allows you to assign default values to parameters within lambda expressions, ushering in a paradigm shift toward conciseness and readability. Let's delve into this exciting addition, exploring its functionalities, advantages, and practical applications through detailed examples.

Default Values

Prior to C# 12, achieving flexible lambda functions often involved lengthy method signatures or cumbersome logic to handle optional parameters. Default lambda parameters break free from these shackles, enabling you.

Navigating the Syntax

Defining default lambda parameters is remarkably straightforward. Simply specify the parameter name followed by an equal sign and the desired default value, enclosed within parentheses.

(parameter1 = defaultValue1, parameter2 = defaultValue2) => expression

Now, let's witness the magic of default lambda parameters in action through illustrative examples across diverse scenarios.

1. String Manipulation

Imagine a function that transforms strings by adding prefixes and suffixes.

string TransformString(string input, string prefix = "Hello, ", string suffix = "!") => prefix + input + suffix;

Console.WriteLine(TransformString("World")); // Output: Hello, World!
Console.WriteLine(TransformString("C# 12", "Welcome to ")); // Output: Welcome to C# 12!

Here, default values for prefixes and suffixes are provided, allowing you to call the function with or without specifying them. Omitting the parameters defaults to the pre-defined values, promoting concise and clear calls.

2. Conditional Operations

Consider a function that performs an action based on a Boolean condition.

Action PerformAction(bool condition = true) => condition ? () => Console.WriteLine("Action executed!") : null;

PerformAction();   // Output: Action executed!
PerformAction(false); // No output

The default true for condition ensures the action is executed by default unless explicitly specified as false. This eliminates the need for lengthy if-else statements, resulting in a more succinct and readable approach.

3. Filtering Collections

Filtering even numbers from a collection becomes a breeze with default parameters.

IEnumerable<int> FilterEvenNumbers(IEnumerable<int> numbers, int threshold = 10) => numbers.Where(x => x % 2 == 0 && x >= threshold);

int[] numbers = { 5, 8, 12, 16, 20 };
var filteredNumbers = FilterEvenNumbers(numbers); // filteredNumbers: { 12, 16, 20 }

The default threshold of 10 allows filtering even numbers above a certain limit. Adjusting this value provides flexibility without altering the function's core logic.

4. Handling Asynchronous Operations

Default parameters shine even in asynchronous scenarios.

async Task<int> GetDataAsync(int requestId, CancellationToken token = default) => await Task.FromResult(42);

// ...

Providing a default CancellationToken streamlines asynchronous operations by handling cancellation without additional parameters.

Remember

Here's a program snippet that demonstrates how to leverage default lambda parameters, filtering, conditional logic, and asynchronous operations.

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

namespace DefaultLambdaParametersDemo
{
    class Program
    {
        static async Task Main(string[] args)
        {
            // Sample data
            List<int> numbers = new List<int>() { 5, 8, 12, 16, 20, 22 };

            // Filter even numbers above a threshold and perform conditional actions
            IEnumerable<int> filteredNumbers = FilterEvenNumbers(numbers, threshold: 15);

            foreach (int number in filteredNumbers)
            {
                Action action = PerformAction(number % 4 == 0); // Use default condition for divisibility by 4
                action?.Invoke();  // Execute action if it's not null
            }

            // Simulate an asynchronous operation with default cancellation token
            int result = await GetDataAsync(requestId: 1);
            Console.WriteLine($"Asynchronous result: {result}");
        }

        // Function with default lambda parameters
        static IEnumerable<int> FilterEvenNumbers(IEnumerable<int> numbers, int threshold = 10)
        {
            return numbers.Where(x => x % 2 == 0 && x >= threshold);
        }

        // Function with conditional logic and default lambda parameter
        static Action PerformAction(bool condition = true)
        {
            return condition ? () => Console.WriteLine("Action executed for number!") : null;
        }

        // Asynchronous function with default cancellation token
        static async Task<int> GetDataAsync(int requestId, CancellationToken token = default)
        {
            await Task.Delay(2000, token);  // Simulate a delay with cancellation support
            return 42; // Sample result
        }
    }
}

Key points in this example

This snippet showcases how these features work together to create code.

Conclusion

Default lambda parameters mark a significant leap forward in C# development. By embracing this powerful feature, you can unleash your creativity, crafting concise, clear, and versatile code that sings with elegance and efficiency. So, dive into the exciting world of default lambda parameters and experience the transformation in your C# coding journey!

This article presents just a glimpse into the vast potential of default lambda parameters. As you delve deeper into this feature, explore its application in areas like event handling, data validation, and functional programming. Embrace the endless possibilities and watch your C# code reach new heights of expressiveness and maintainability.