How to use pattern matching in C#?

Pattern matching in C# is a feature used to check objects against patterns and extract information concisely. 1. Type patterns allow checking and casting in one step, as shown with if (value is string str). 2. Constant patterns compare values against constants directly, such as checking if (input is null). 3. Switch expressions with patterns simplify logic, demonstrated by shape switch returning different strings based on shape type. 4. Recursive patterns match nested structures, like checking person is { Name: "Alice", Address: { City: "Wonderland" } }. Overall, pattern matching improves code readability and expressiveness when used appropriately.

Pattern matching in C# is a powerful feature that allows you to check an object against a pattern and extract information from it in a concise and readable way. It’s especially useful when working with different types, conditions, or structures.

Here are a few practical ways you can use pattern matching in your C# code:

1. Type Patterns – Check and Cast in One Step

One of the most common uses of pattern matching is to check the type of an object and cast it at the same time.

if (value is string str)
{
    Console.WriteLine($"It's a string: {str.ToUpper()}");
}

This replaces older code like:

if (value is string)
{
    string str = (string)value;
    // ...
}

This is cleaner and avoids repeating the variable name or doing a separate cast.

2. Constant Patterns – Match Specific Values

You can use pattern matching to compare values against constants directly in a condition.

if (input is null)
{
    Console.WriteLine("Input is null");
}

Or with numeric values:

switch (number)
{
    case 0:
        Console.WriteLine("Zero");
        break;
    case var n when n > 0:
        Console.WriteLine("Positive");
        break;
}

This can make conditional logic easier to read, especially when combined with switch expressions.

3. Switch Expressions with Patterns

C# 8 introduced switch expressions, which work well with pattern matching to simplify logic.

string result = shape switch
{
    Rectangle r => $"Rectangle: {r.Width}x{r.Height}",
    Circle c => $"Circle: radius {c.Radius}",
    null => "No shape",
    _ => "Unknown shape"
};

This replaces longer switch statements and makes the code more expressive. The _ is a discard pattern that matches anything not covered above.

4. Recursive Patterns – Match Nested Structures

In C# 9 and later, you can use recursive patterns to match nested properties. For example:

if (person is { Name: "Alice", Address: { City: "Wonderland" } })
{
    Console.WriteLine("Found Alice from Wonderland");
}

This is useful when you want to check deeply nested data without writing multiple nested if conditions.

A few things to keep in mind:

• Pattern matching works best with is, switch, and in some cases with switch expressions.
• You can combine patterns with when clauses for more complex conditions.
• Avoid overusing it in deeply nested logic where readability might suffer.

Pattern matching in C# helps you write cleaner, more expressive code once you get used to the syntax. It’s not overly complex, but it does take a bit of practice to know when and how to use it effectively.

The above is the detailed content of How to use pattern matching in C#?. For more information, please follow other related articles on the PHP Chinese website!