C#中的模式匹配通過is表達式和switch表達式使條件邏輯更簡潔、更具表現(xiàn)力。 1. 使用is表達式可進行簡潔的類型檢查，如if (obj is string s)，同時提取值；2. 可結(jié)合邏輯模式（and、or、not）簡化條件判斷，如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 meant 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 gives 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.

以上是C＃中的模式匹配（例如表達式，開關(guān)表達式）如何簡化條件邏輯？的詳細內(nèi)容。更多信息請關(guān)注PHP中文網(wǎng)其他相關(guān)文章！