List patterns in C# 11

In C# 11, a powerful new feature was introduced called List patterns. Pattern matching is not new to C#, but List patterns take it a step further by allowing developers to match sequences and collections in a more expressive and concise manner. In this blog post, we’ll explore what List patterns are, how to use them, and see some practical examples to get you started.

Understanding List Patterns

List patterns allow you to match elements of a list or array in a sequence. This feature can be especially useful when you need to destructure a list and match its elements against specific criteria. Unlike traditional pattern matching, List patterns provide a more intuitive way to work with collections.

Basic Syntax and Examples

The basic syntax of a List pattern involves using square brackets to denote a list and specifying the elements to match within those brackets. Here’s a simple example:

int[] numbers = { 1, 2, 3, 4, 5 };

if (numbers is [1, 2, 3, 4, 5])
{
    Console.WriteLine("The list matches exactly [1, 2, 3, 4, 5]");
}
else
{
    Console.WriteLine("The list does not match.");
}

In this example, we check if the numbers array matches the exact sequence [1, 2, 3, 4, 5].

Advanced Usage

List patterns can be combined with other pattern matching techniques to create more complex conditions. For example:

int[] numbers = { 1, 2, 3, 4, 5 };

if (numbers is [1, 2, .., 5])
{
    Console.WriteLine("The list starts with 1 and ends with 5.");
}
else
{
    Console.WriteLine("The list does not match the pattern.");
}

Here, .. (the “slice” pattern) matches any number of elements between 1 and 5.

Practical Applications

List patterns are particularly useful in scenarios where you need to validate or destructure input data. For example, suppose you have a function that processes a list of commands:

void ProcessCommands(string[] commands)
{
    if (commands is ["start", .., "end"])
    {
        Console.WriteLine("Processing commands from start to end.");
    }
    else
    {
        Console.WriteLine("Invalid command sequence.");
    }
}

This function checks if the commands array starts with “start” and ends with “end”, regardless of the commands in between.

Performance Considerations

While List patterns offer a concise and readable way to match sequences, it’s important to consider performance implications, especially with large collections. Always profile your code and ensure that the use of List patterns does not introduce unnecessary overhead.

Conclusion

List patterns in C# 11 provide a powerful tool for matching and destructing sequences. By leveraging this feature, you can write more expressive and concise code. We hope this blog post has given you a good understanding of List patterns and inspired you to experiment with them in your own projects.

Additional Resources
Official Documentation on List Patterns