Pattern matching (greatly expanded in recent C# versions) lets you test a value's shape, type, and properties concisely, and extract data — making complex conditional logic far cleaner than nested if-else chains. It's used with switch expressions, is, and more.
(obj s)
Console.WriteLine(s.Length);
(obj n > )
Console.WriteLine();
The is operator with a type pattern tests the type and captures the value (typed) in one step — cleaner than a separate check-then-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 expressions support rich patterns: type patterns, conditions (when), and property patterns ({ Length: > 10 } — matching on an object's properties) — expressing complex branching concisely.
// 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 an important and increasingly central feature of modern C# — it has been greatly expanded across recent versions, transforming how C# handles conditional logic and type checking, so understanding it is valuable for writing and reading current C# code.
Its core value is expressing complex conditional logic concisely and readably: instead of nested if-else chains with separate type checks, casts, and property accesses, pattern matching lets you test a value's type, conditions, properties, and structure — and extract data — in clean, declarative expressions (especially with switch expressions).
The breadth of patterns — type patterns (test and capture types in one step via is), property patterns (match on object properties), relational and logical patterns (< 100 and > 0, not), and list/positional patterns — covers a wide range of branching logic elegantly.
This reflects modern C#'s evolution toward more functional, expressive code, and pattern matching appears extensively in current codebases (especially with switch expressions and records).
Understanding the various patterns and how to use them (with is, switch expressions, when clauses) is important for writing concise, readable modern C# and for reading code that uses these features.
Since pattern matching replaces verbose conditional logic with clean, declarative expressions — improving readability and reducing bugs — and since it's a defining feature of modern C# that keeps expanding, mastering it is valuable, frequently-applied knowledge that distinguishes fluent modern C# from older, more verbose styles, and is an increasingly common interview topic.