Exploring Advanced Pattern Matching in C# 9+

Pattern matching in C# has evolved significantly over the years, with C# 9 introducing property patterns, relational patterns, logical patterns, and type patterns, making it even more expressive and concise. In this blog, we’ll explore different ways to use these features to simplify common coding scenarios.

1. Basic Property Pattern Matching

Property patterns allow you to check specific properties of an object directly within an is expression.

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

Person person = new Person { Name = "Alice", Age = 30 };

if (person is { Age: 30 })
{
    Console.WriteLine("This person is 30 years old.");
}

Here, we check if person.Age is exactly 30 in a clean, declarative way.

2. Combining Property Patterns

You can also check multiple properties at once.

if (person is { Name: "Alice", Age: >= 30 })
{
    Console.WriteLine("Alice is 30 or older.");
}

This ensures both conditions are met before executing the code inside the block.

3. Using Property Patterns in Method Parameters

Property patterns can be used directly in method parameters to validate objects concisely.

void PrintPersonInfo(Person person)
{
    if (person is { Name: "Bob", Age: > 25 })
    {
        Console.WriteLine("Bob is older than 25.");
    }
}

This eliminates the need for verbose null checks and multiple if conditions.

4. Applying Property Patterns in Switch Expressions

Pattern matching also enhances switch expressions, making them more powerful.

string GetPersonCategory(Person person) => person switch
{
    { Age: < 18 } => "Child",
    { Age: >= 18 and <= 60 } => "Adult",
    { Age: > 60 } => "Senior",
    _ => "Unknown"
};

This makes decision-making more expressive and removes unnecessary if-else chains.

5. Using Property Patterns with Collections

You can also apply property patterns on collections, such as checking the count of elements.

List<string> names = new() { "Alice", "Bob", "Charlie" };

if (names is { Count: > 2 })
{
    Console.WriteLine("More than two names in the list.");
}

Here, we use { Count: > 2 } to check if the collection contains more than two elements.

6. Null-Safe Pattern Matching

Property patterns work well with null-safe navigation, reducing the risk of NullReferenceException.

if (person?.Name is { Length: > 3 })
{
    Console.WriteLine("Person's name has more than 3 characters.");
}

The ?. operator ensures that Name is not null before checking its length.

7. Logical Patterns (and, or, not)

C# 9 introduced logical patterns (and, or, not) to make pattern matching more expressive.

if (person is { Age: >= 18 and <= 25 })
{
    Console.WriteLine("This person is a young adult.");
}

You can also use or to check for multiple conditions.

if (person is { Age: < 18 or > 60 })
{
    Console.WriteLine("This person is either a minor or a senior citizen.");
}

And not to invert conditions:

if (person is not { Age: < 18 })
{
    Console.WriteLine("This person is an adult.");
}

8. Type Patterns in Switch Expressions

Type patterns allow checking object types concisely in switch expressions.

object obj = "Hello";

string message = obj switch
{
    string s => $"It's a string: {s}",
    int i => $"It's an integer: {i}",
    _ => "Unknown type"
};

Console.WriteLine(message);

This avoids the need for if statements and explicit casting.

9. Positional Pattern Matching (for Deconstruction)

You can match tuples or deconstructed objects with positional patterns.

(int x, int y) point = (3, 4);

string location = point switch
{
    (0, 0) => "Origin",
    (0, _) => "On the Y-axis",
    (_, 0) => "On the X-axis",
    _ => "Somewhere else"
};

Console.WriteLine(location);

This is especially useful when working with tuples or record types.

10. Combining Multiple Pattern Types

You can combine different pattern types in complex scenarios for better code clarity.

static string GetShapeDescription(object shape) => shape switch
{
    Circle { Radius: > 10 } => "Large Circle",
    Rectangle { Width: > 10, Height: > 10 } => "Large Rectangle",
    { } => "Some other shape",
    null => "No shape provided"
};

This example combines property patterns with type patterns to classify different shapes dynamically.

11. Matching on Records

Pattern matching is particularly useful with C# record types.

public record Vehicle(string Type, int Wheels);

Vehicle vehicle = new("Car", 4);

string category = vehicle switch
{
    { Type: "Car", Wheels: 4 } => "Standard Car",
    { Type: "Motorcycle", Wheels: 2 } => "Two-Wheeler",
    _ => "Unknown Vehicle"
};

Console.WriteLine(category);

Using records makes pattern matching even more powerful and immutable-friendly.