Vilka mönstermatchningsmekanismer stöds i modernt C#?

Question

Accepted Answer

**Mönstermatchning** (kraftigt utökad i senare C#-versioner) låter dig testa ett värdes **form, typ och egenskaper** på ett koncist sätt och extrahera data — vilket gör komplex betingad logik mycket renare än kapslade if-else-kedjor. Det används med `switch`-uttryck, `is` och mer till. ## Typmönster och is-operatorn ```csharp // type pattern — test type AND capture in one step if (obj is string s) Console.WriteLine(s.Length); // s is typed as string here (no separate cast) if (obj is int n and > 0) // combine: type + condition Console.WriteLine("positive int"); ``` `is`-operatorn med ett typmönster testar typen och fångar värdet (typat) i ett steg — renare än en separat kontroll-sedan-cast. ## Switch-uttryck med mönster ```csharp string Describe(object obj) => obj switch { int n when n > 0 => "positive int", // type + condition (when) int => "non-positive int", string { Length: > 10 } => "long string", // property pattern null => "null", _ => "other", // default }; ``` Switch-uttryck stöder rika mönster: typmönster, villkor (`when`), och **egenskapsmönster** (`{ Length: > 10 }` — matchning på ett objekts egenskaper) — vilket uttrycker komplex förgrening på ett koncist sätt. ## Egenskaps-, relations- och logiska mönster ```csharp // property pattern — match on properties var discount = customer switch { { IsVip: true, Orders: > 100 } => 0.2, // multiple property conditions { Orders: > 50 } => 0.1, _ => 0.0, }; // relational + logical patterns (C# 9) string Size(int n) => n switch { < 0 => "negative", 0 => "zero", > 0 and < 100 => "small", // relational (< >) + logical (and/or/not) _ => "large", }; ``` ## Lista och positionsmönster (C# 11 / poster) ```csharp var (x, y) = point; // positional/deconstruction int[] arr = { 1, 2, 3 }; if (arr is [1, .., 3]) { } // list pattern (C# 11) — starts with 1, ends with 3 ``` ## Varför det är viktigt Mönstermatchning är en viktig och alltmer central funktion i modernt C# — den har utökats kraftigt i senare versioner och transformerar hur C# hanterar betingad logik och typkontroll, så att förstå den är värdefullt för att skriva och läsa aktuell C#-kod. Its grundläggande värde är att uttrycka **komplex betingad logik på ett koncist och läsbart sätt**: istället för kapslade if-else-kedjor med separata typkontroller, caster och egenskapsåtkomst, låter mönstermatchning dig testa ett värdes typ, villkor, egenskaper och struktur — och extrahera data — i rena, deklarativa uttryck (särskilt med switch-uttryck). Breden av mönster — **typmönster** (testa och fånga typer i ett steg via `is`), **egenskapsmönster** (matchning på objektegenskaper), **relations- och logiska mönster** (`< 100 and > 0`, `not`), och lista-/positionsmönster — täcker ett brett spektrum av förgrenningslogik på ett elegant sätt. Detta reflekterar modernt C#:s utveckling mot mer funktionell, uttrycksrik kod, och mönstermatchning förekommer i stor utsträckning i moderna kodbaser (särskilt med switch-uttryck och poster). Att förstå de olika mönstren och hur man använder dem (med `is`, switch-uttryck, `when`-satser) är viktigt för att skriva koncis, läsbar modern C# och för att läsa kod som använder dessa funktioner. Själf då mönstermatchning ersätter verbose betingad logik med rena, deklarativa uttryck — vilket förbättrar läsbarheten och minskar buggar — och då det är en definerande funktion av modernt C# som fortsätter att expandera, är att bemästra det värdefullt, ofta använd kunskap som skiljer flytande modernt C# från äldre, mer verbosa stilar, och är ett alltmer vanligt intervjuämne.