Le pattern matching (considérablement enrichi dans les récentes versions de C#) vous permet de tester la forme, le type et les propriétés d'une valeur de manière concise, et d'en extraire des données — rendant la logique conditionnelle complexe bien plus claire que des chaînes imbriquées de if-else. Il est utilisé avec les switch expressions, is, et bien d'autres.
// 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");
L'opérateur is avec un motif de type teste le type et capture la valeur (typée) en une seule étape — plus clair qu'une vérification puis cast séparé.
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
};
Les switch expressions supportent des motifs riches : motifs de type, conditions (when), et motifs de propriétés ({ Length: > 10 } — correspondance sur les propriétés d'un objet) — exprimant les ramifications complexes de manière concise.
// 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
Le pattern matching est une fonctionnalité importante et de plus en plus centrale du C# moderne — il a été considérablement enrichi au cours des récentes versions, transformant la façon dont C# gère la logique conditionnelle et la vérification de type. Le comprendre est donc précieux pour écrire et lire du code C# actuel.
Sa valeur fondamentale réside dans l'expression claire et lisible de la logique conditionnelle complexe : au lieu de chaînes imbriquées de if-else avec vérifications de type, cast et accès aux propriétés séparés, le pattern matching vous permet de tester le type d'une valeur, ses conditions, ses propriétés et sa structure — et d'en extraire les données — dans des expressions nettes et déclaratives (particulièrement avec les switch expressions).
L'étendue des motifs — motifs de type (test et capture de types en une étape via is), motifs de propriétés (correspondance sur les propriétés d'un objet), motifs relationnels et logiques (< 100 and > 0, not), et motifs de liste/positionnels — couvre une large gamme de logiques de ramification de manière élégante.
Cela reflète l'évolution du C# moderne vers un code plus fonctionnel et expressif, et le pattern matching apparaît largement dans les codebases actuelles (particulièrement avec les switch expressions et les records).
Comprendre les différents motifs et comment les utiliser (avec is, les switch expressions, les clauses when) est important pour écrire du C# moderne concis et lisible, et pour lire du code qui utilise ces fonctionnalités.
Comme le pattern matching remplace la logique conditionnelle verbeuse par des expressions nettes et déclaratives — améliorant la lisibilité et réduisant les bogues — et puisque c'est une fonctionnalité définissante du C# moderne qui continue de s'enrichir, le maîtriser est une connaissance précieuse et fréquemment appliquée qui distingue le C# moderne fluide des styles plus anciens et verbeux, et c'est un sujet d'entretien de plus en plus courant.