Pattern matching in C# makes the conditional logic more concise and expressive through is expressions and switch expressions. 1. Use is expressions to perform concise type checks, such as if (obj is string s), and extract values ??at the same time; 2. It can simplify conditional judgments in combination with logical patterns (and, or, not), such as value is > 0 and

Pattern matching in C#—especially with is expressions and switch expressions—makes conditional logic cleaner, more expressive, and often easier to maintain. It helps you write code that's focused on the shape or structure of data rather than just its type or value.

Using is expressions for concise type checks

Before C# 7, checking types usually means using a combination of is followed by an explicit cast:

 if (obj is string) {
    string s = (string)obj;
    // do something with s
}

With pattern matching, you can simplify this into a single line:

 if (obj is string s) {
    // use s directly
}

This approach reduces boilerplate and keeps your logic tight. You're not just checking a condition—you're extracting usable values ??at the same time.

Another handy use is combining it with logical patterns ( and , or , not ). For example:

 if (value is > 0 and < 10) {
    // value is between 1 and 9
}

Or filtering out nulls:

 if (input is not null) { 
    // proceed safely
}

These make simple conditions easier to read and write without extra nesting or casting.

Switch expressions for clean multi-case logic

Traditional switch statements were limited—they mostly worked with primitive types like int or string , and required verbose syntax with case , break , and so on.

C# 8 introduced switch expressions , which are much more flexible and compact. They work with any type and support pattern matching:

 var result = shape switch {
    Circle c => $"Circle with radius {c.Radius}",
    Rectangle r => $"Rectangle {r.Width}x{r.Height}",
    _ => "Unknown shape"
};

Here, each case matches both the type and optionally extracts properties. The _ acts as a default fallback.

This style removes a lot of ceremony from the older switch syntax. It also enforces exhaustiveness, meaning the compiler will warn you if you miss a possible case.

You can even match based on property values:

 var message = person switch {
    { Age: < 18 } => "Minor",
    { Age: >= 65 } => "Senior",
    _ => "Adult"
};

This makes complex conditional logic feel more declarative and less procedural.

Where pattern matching really shines

Pattern matching becomes especially useful when dealing with nested or hierarchical data structures. For example, in domain models where different types behave differently, pattern matching lets you inspect and respond to those differences clearly.

It's also great in LINQ queries or filtering operations where you want to extract or transform data based on its structure:

 var adults = people.Where(p => p is { Age: >= 18 });

That one-liner filters out only adults, using property pattern matching.

In recursive data structures like trees or expressions, pattern matching can help you deconstruct nodes cleanly and handle each case without deep nesting.

So, yeah, pattern matching in C# doesn't just save keystrokes—it improves readability, reduces error-prone casting, and give you a clearer way to express intent. Once you get used to writing things like is string s or using switch expressions with rich patterns, going back feels clunky.

The above is the detailed content of How does pattern matching in C# (e.g., is expressions, switch expressions) simplify conditional logic?. For more information, please follow other related articles on the PHP Chinese website!