Pattern matching (sterk uitgebreid in recente C#-versies) laat je de vorm, type en eigenschappen van een waarde bondig testen en gegevens extraheren — waardoor complexe voorwaardelijke logica veel schoner wordt dan geneste if-else-ketens. Het wordt gebruikt met switch expressies, is en meer.
(obj s)
Console.WriteLine(s.Length);
(obj n > )
Console.WriteLine();
De is operator met een type pattern test het type en legt de waarde (getypeerd) in één stap vast — schoner dan een aparte check-en-cast.
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 expressies ondersteunen rijke patterns: type patterns, voorwaarden (when), en property patterns ({ Length: > 10 } — matching op eigenschappen van een object) — waardoor complexe vertakkingen bondig kunnen worden uitgedrukt.
// 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",
};
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
Pattern matching is een belangrijke en steeds centraler wordende feature van modern C# — het is sterk uitgebreid over recente versies, wat de manier waarop C# met voorwaardelijke logica en type checking omgaat fundamenteel transformeert, dus het begrijpen ervan is waardevol voor het schrijven en lezen van huidige C#-code.
De kernwaarde ervan is het bondig en leesbaar uitdrukken van complexe voorwaardelijke logica: in plaats van geneste if-else-ketens met aparte type checks, casts en property accesses, laat pattern matching je het type, voorwaarden, eigenschappen en structuur van een waarde testen — en gegevens extraheren — in schone, declaratieve expressies (vooral met switch expressies).
De breedte van patterns — type patterns (test en leg types vast in één stap via is), property patterns (match op object eigenschappen), relational en logical patterns (< 100 and > 0, not), en list/positional patterns — dekt een breed scala aan vertakkingslogica elegant af.
Dit weerspiegelt de evolutie van modern C# naar meer functionele, expressieve code, en pattern matching komt veel voor in huidige codebases (vooral met switch expressies en records).
Het begrijpen van de verschillende patterns en hoe ze te gebruiken (met is, switch expressies, when clausules) is belangrijk voor het schrijven van bondig, leesbaar modern C# en voor het lezen van code die deze features gebruikt.
Omdat pattern matching uitgebreide voorwaardelijke logica vervangt door schone, declaratieve expressies — wat leesbaarheid verbetert en bugs reduceert — en omdat het een definiërend kenmerk van modern C# is dat steeds verder uitbreidt, is het beheersen ervan waardevol, veelvuldig toegepast kennis dat vloeiend modern C# onderscheidt van oudere, meer uitgebreide stijlen, en is het een steeds frequenter interview-onderwerp.