C#模式匹配通過(guò)簡(jiǎn)化類型檢查和條件邏輯使代碼更簡(jiǎn)潔。使用模式匹配替換類型檢查和轉(zhuǎn)換，如if(obj is string s)一步完成類型檢查與轉(zhuǎn)換；利用C#8的switch表達(dá)式簡(jiǎn)化複雜的條件判斷，如用item switch{...}替代多個(gè)if-else分支；通過(guò)when子句匹配複雜模式，如shape is Rectangle r when r.Width == r.Height在類型匹配時(shí)附加條件驗(yàn)證，從而減少冗餘代碼並提升可讀性。

C# pattern matching can make your code a lot cleaner, especially when dealing with conditionals and type checks. It's not just syntactic sugar—it actually helps reduce boilerplate and improves readability if used right.

Use Pattern Matching to Replace Type Checks and Casts

Before C# 7, checking types often meant doing something like this:

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

With pattern matching, you can simplify that into one line:

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

This avoids having to cast separately and keeps the logic tight. It works with any type check, not just primitives—so for custom objects, it's equally useful. Just keep in mind that the variable declared here ( s in this case) is only available inside the if block. That scoping behavior helps prevent accidental misuse, but also means you need to handle everything within that block.

Simplify Conditional Logic with Switch Expressions

Switch expressions introduced in C# 8 take pattern matching even further. Instead of writing multiple if-else conditions, you can use a switch expression that returns a value based on patterns.

For example, instead of:

 string GetCategory(object item)
{
    if (item is null)
        return "Unknown";

    if (item is Product p && p.Price > 100)
        return "Premium";

    if (item is Product)
        return "Standard";

    if (item is string s && s.Length > 10)
        return "Long Text";

    return "Other";
}

You can write it more cleanly like this:

 string GetCategory(object item) => item switch
{
    null => "Unknown",
    Product { Price: > 100 } => "Premium",
    Product _ => "Standard",
    string s when s.Length > 10 => "Long Text",
    _ => "Other"
};

It's more readable, and the structure makes it easier to see what each case does without getting lost in nested conditions.

A few things to note:

• You can match on properties directly using Type { Property: value }
• The _ after Product _ is optional, but some people include it to indicate the variable isn't being used beyond matching
• Order matters—put more specific cases first, otherwise a general case might swallow them

Match Complex Patterns with When Clauses

Sometimes, you don't just want to check the type—you also want to inspect values or conditions. That's where when comes in handy.

Take this example:

 if (shape is Rectangle r when r.Width == r.Height)
{
    Console.WriteLine("It's a square!");
}

Without pattern matching, you'd have to cast first and then check the condition separately. With pattern matching, it all happens in one step.

You can use when in both if statements and switch expressions. It gives you a clean way to filter based on additional criteria while still benefiting from type inference and concise syntax.

One thing to watch out for: when doesn't introduce new scope variables unless you explicitly declare them. So if you're doing multiple checks, be sure to capture the variable correctly.

That's basically how pattern matching helps clean up your C# code. It reduces clutter, avoids repetitive casting, and makes conditional logic easier to read and maintain. Doesn't require advanced tricks—just knowing where and how to apply these features makes a big difference.

以上是使用C＃模式匹配的清潔代碼的詳細(xì)內(nèi)容。更多資訊請(qǐng)關(guān)注PHP中文網(wǎng)其他相關(guān)文章！