{"id":2311,"date":"2024-07-13T11:10:38","date_gmt":"2024-07-13T09:10:38","guid":{"rendered":"https:\/\/cdiese.fr\/?p=2311"},"modified":"2025-06-14T01:58:38","modified_gmt":"2025-06-13T23:58:38","slug":"cheat-sheet-pattern-matching","status":"publish","type":"post","link":"https:\/\/cdiese.fr\/cheat-sheet-pattern-matching\/","title":{"rendered":"Aide-m\u00e9moire pattern matching C#"},"content":{"rendered":"

Cet article est un aide-m\u00e9moire des motifs les plus courants de pattern matching<\/i> suivant les versions de C# pour aider \u00e0 se rappeler de la syntaxe:<\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Motif<\/th>\nVersion C#<\/th>\nRemarques et exemples<\/th>\n<\/tr>\n<\/thead>\n
Null pattern<\/b><\/td>\nC# 7.0<\/b><\/td>\nTest pour v\u00e9rifier si une variable est nulle<\/b><\/p>\n
Vehicle vehicle = new Car();  \r\nif (vehicle is null)  \r\n  Console.WriteLine($\"{nameof(vehicle)} is null.\");  \r\nelse  \r\n  Console.WriteLine($\"{nameof(vehicle)} is not null.\");<\/code><\/pre>\n<\/td>\n<\/tr>\n
Constant pattern<\/b><\/td>\nC# 7.0<\/b><\/td>\nComparaison entre une variable et une constante<\/b><\/p>\n
object carAsObj = new Car();  \r\nif (carAsObj is \"45\")  \r\n  Console.WriteLine($\"{nameof(carAsObj)} is 45.\");  \r\nelse  \r\n  Console.WriteLine($\"{nameof(carAsObj)} is not 45.\");\r\n<\/code><\/pre>\n<\/td>\n<\/tr>\n
Type pattern<\/b><\/td>\n< C# 7.0<\/b><\/td>\nTest par rapport \u00e0 un type:<\/b>
\nSi on consid\u00e8re les types:<\/p>\n
class Vehicle\r\n{\r\n    public string Name;\r\n}\r\n\r\nclass MotoBike : Vehicle\r\n{\r\n    public int Power => 100;\r\n}\r\n\r\nclass Car : Vehicle\r\n{\r\n    public int PassengerCount { get; set; }\r\n}\r\n<\/code><\/pre>\n
Avant C# 7.0, on pouvait effectuer les tests suivants:<\/p>\n
if (vehicle is Car)  \r\n  Console.WriteLine($\"{nameof(vehicle)} is a car.\");  \r\nelse if (vehicle is Motobike)  \r\n  Console.WriteLine($\"{nameof(vehicle)} is a motobike.\");  \r\nelse  \r\n  Console.WriteLine($\"{nameof(vehicle)} has not been identified.\"); \r\n<\/code><\/pre>\n<\/td>\n<\/tr>\n
C# 7.0<\/b><\/td>\nTest par rapport \u00e0 un type et cast<\/i> (utilisation implicite de as<\/code>).<\/b><\/p>\n

Avec le motif type<\/i>, \u00e0 partir de C# 7.0, on peut \u00e9crire:<\/p>\n

if (vehicle is Car car<\/u>)  \r\n  Console.WriteLine($\"{nameof(vehicle)} is a car with {car.PassengerCount} passagers.\");  \r\nelse if (vehicle is Motobike motoBike<\/u>)  \r\n  Console.WriteLine($\"{nameof(vehicle)} is a motobike of {motobike.Power} horsepower.\");  \r\nelse  \r\n  Console.WriteLine($\"{nameof(vehicle)} has not been identified.\");\r\n<\/code><\/pre>\n<\/td>\n<\/tr>\n
Construction switch...case<\/code><\/td>\nC# 7.0<\/b><\/td>\n\n
object carAsObj = new Car();  \r\nswitch (carAsObj)  \r\n{  \r\n  case null:  \/\/ Null pattern\r\n    Console.WriteLine(\"Is null\");  \r\n    break;  \r\n  case \"45\":  \/\/ Constant pattern \r\n    Console.WriteLine(\"Is a constant, not a vehicle.\");  \r\n    break;  \r\n  case Car car:  \/\/ Type pattern\r\n    Console.WriteLine($\"{nameof(carAsObj)} is a car with {car.PassengerCount} passagers.\");  \r\n    break;  \r\n  case Motobike motobike:  \/\/ Type pattern\r\n    Console.WriteLine($\"{nameof(carAsObj)} is a motobike of {motobike.Power} horsepower.\");  \r\n    break;  \r\n  default:  \r\n    Console.WriteLine($\"{nameof(carAsObj)} has not been identified.\");  \r\n    break;  \r\n} \r\n<\/code><\/pre>\n<\/td>\n<\/tr>\n
Ajouter des conditions avec when<\/code> et switch...case<\/code><\/td>\nC# 7.0<\/b><\/td>\n\n
Vehicle vehicle = new Car();  \r\nswitch (vehicle)  \r\n{  \r\n  case Car car when<\/u> car.PassengerCount < 1:  \r\n    Console.WriteLine($\"{nameof(vehicle)} is an empty car.\");  \r\n    break;  \r\n  case Car car when<\/u> car.PassengerCount > 3 && car.PassengerCount <= 5:  \r\n    Console.WriteLine($\"{nameof(vehicle)} is a fully loaded car.\");  \r\n    break;  \r\n  case Car car when<\/u> car.PassengerCount > 8:  \r\n    Console.WriteLine($\"{nameof(vehicle)} is a heavy loaded car.\");  \r\n    break;  \r\n  default:  \r\n    Console.WriteLine($\"{nameof(vehicle)} has not been identified.\");  \r\n    break;  \r\n}\r\n<\/code><\/pre>\n<\/td>\n<\/tr>\n
var pattern<\/b><\/td>\nC# 7.0<\/b><\/td>\nCe motif donne l’impression d’appliquer une condition avec l’op\u00e9rateur is<\/code> toutefois ce n’est pas le cas, la clause est toujours vraie. L’int\u00e9r\u00eat est d’effectuer une affectation du r\u00e9sultat de l’expression dans une variable qui pourra \u00eatre utilis\u00e9e pour d’autres conditions:
\n<expression<\/b><\/i>><\/span> is var <nom de la variable<\/b><\/i>><\/span><\/code> est toujours vraie, le r\u00e9sultat de <expression<\/b><\/i>><\/span><\/code> est affect\u00e9 dans la variable <nom de la variable<\/b><\/i>><\/span><\/code>. <\/p>\n

Par exemple:<\/p>\n

List<Vehicle> vehicles = new List<Vehicle>{ new Car() }; \r\n\/\/ Toujours vrai, le r\u00e9sultat est dans bigVehicle\r\nif (vehicles.FirstOrDefault(v => v.GetWheelCount() > 3) is var bigVehicle<\/b>)\r\n{ \r\n  if (bigVehicle.GetWheelCount() == 4) \r\n    Console.WriteLine(\"The vehicle is a car\"); \r\n  else if (bigVehicle.GetWheelCount() == 6) \r\n    Console.WriteLine(\"The vehicle is a little truck\"); \r\n  else if (bigVehicle.GetWheelCount() > 6) \r\n    Console.WriteLine(\"The vehicle is a big truck\"); \r\n}\r\n<\/code><\/pre>\n
Utilisation avec switch...case<\/code>:<\/p>\n
switch(vehicles.FirstOrDefault(v => v.GetWheelCount() > 3)) \r\n{ \r\n  case null: \r\n    Console.WriteLine(\"No big vehicle round\"); \r\n    break; \r\n  case var car<\/u> when car.GetWheelCount() == 4: \r\n    Console.WriteLine(\"The vehicle is a little truck\"); \r\n    break; \r\n  case var truck<\/u> when truck.GetWheelCount() == 6: \r\n    Console.WriteLine(\"The vehicle is a little truck\"); \r\n    break; \r\n  case var bigTruck<\/u> when bigTruck.GetWheelCount() > 6: \r\n    Console.WriteLine(\"The vehicle is a big truck\"); \r\n    break; \r\n}\r\n<\/code><\/pre>\n<\/td>\n<\/tr>\n
Expression switch<\/code><\/b><\/td>\nC# 8<\/b><\/td>\nSyntaxe permettant de faciliter l’affectation d’une variable suivant plusieurs conditions:<\/p>\n
<nouvelle variable \u00e0 assigner<\/b><\/i>><\/span> = <variable existante<\/b><\/i>><\/span> switch\r\n{\r\n  <condition 1<\/b><\/i>><\/span> => <expression 1<\/b><\/i>><\/span>,\r\n  <condition 2<\/b><\/i>><\/span> => <expression 2<\/b><\/i>><\/span>,\r\n  \/\/ ...\r\n};<\/code><\/pre>\n
Par exemple:<\/p>\n
Vehicle vehicle = new Car{ Name = \"Car1\"  };\r\nstring text = vehicle switch\r\n{\r\n  Car car => $\"The vehicle is a car: {car.Name}\",\r\n  MotoBike moto => $\"The vehicle is a motobike: {moto.Name}\",\r\n  null => \"No vehicle\", \/\/ null pattern\r\n  _ => throw new InvalidOperationException(\"Vehicle is unknown\"), \/\/ discard pattern (cas par d\u00e9faut)\r\n};\r\n<\/code><\/pre>\n<\/td>\n<\/tr>\n
Type pattern<\/b> dans une expression switch<\/code><\/td>\nC# 8<\/b><\/td>\nPour tester par rapport \u00e0 un type dans une expression switch<\/code>.<\/b><\/p>\n
Vehicle vehicle = new Car{ Name = \"Car1\"  };\r\nstring text = vehicle switch\r\n{\r\n  Car car => $\"The vehicle is a car: {car.Name}\",\r\n  MotoBike moto => $\"The vehicle is a motobike: {moto.Name}\",\r\n  \/\/ [...]\r\n};\r\n<\/code><\/pre>\n<\/td>\n<\/tr>\n
C# 9<\/b><\/td>\nOn peut supprimer la variable si on ne l’utilise pas par la suite.<\/b> <\/p>\n
Vehicle vehicle = new Car{ Name = \"Car1\"  };\r\nstring text = vehicle switch\r\n{\r\n  Car => \"The vehicle is a car\",\r\n  MotoBike => \"The vehicle is a motobike\",\r\n  \/\/ [...]\r\n};\r\n<\/code><\/pre>\n<\/td>\n<\/tr>\n
null pattern<\/b><\/td>\nC# 9<\/b><\/td>\nA utiliser avec une expression switch<\/code> pour tester si une variable est nulle.<\/b><\/p>\n
Vehicle vehicle = new Car{ Name = \"Car1\"  };\r\nstring text = vehicle switch\r\n{\r\n  \/\/ [...]\r\n  null => \"No vehicle\", \/\/ null pattern\r\n  \/\/ [...]\r\n};\r\n<\/code><\/pre>\n
La valeur \"No vehicle\"<\/code> est affect\u00e9e \u00e0 text<\/code> si vehicle est null<\/code>. <\/td>\n<\/tr>\n
Discard pattern<\/b><\/td>\nC# 9<\/b><\/td>\nC’est le cas par d\u00e9faut dans une expression switch<\/code>.<\/b><\/p>\n

Ce cas s’applique si aucune autre condition n’est satisfaite (cas par d\u00e9faut).<\/p>\n

string text = vehicle switch\r\n{\r\n  \/\/ [...]\r\n  _ => throw new InvalidOperationException(\"Vehicle is unknown\"),\r\n};\r\n<\/code><\/pre>\n<\/td>\n<\/tr>\n
Ajouter des conditions avec when<\/code> dans une expression switch<\/code><\/td>\nC# 9<\/b><\/td>\n\n
string text = vehicle switch\r\n{\r\n  Car car when<\/u> string.IsNullOrEmpty(car.Name) => $\"The vehicle is a car\",\r\n  Car car when<\/u> car.Name.Equals(\"Car1\") => $\"The vehicle is the first car\",\r\n  Car car => $\"The vehicle is a car: {car.Name}\",\r\n  _ => throw new InvalidOperationException(\"Vehicle is unknown\"), \/\/ cas par d\u00e9faut\r\n};\r\n<\/code><\/pre>\n<\/td>\n<\/tr>\n
var pattern<\/b> avec une expression switch<\/code><\/td>\nC# 9<\/b><\/td>\nCe motif s’applique quelque soit le type de variable (la condition est toujours vraie).<\/b><\/p>\n

L’int\u00e9r\u00eat est d’effectuer une affectation de l’expression dans une variable qui pourra \u00e9ventuellement \u00eatre utilis\u00e9e dans le reste de l’expression.<\/p>\n

string text = vehicle switch\r\n{\r\n  \/\/ [...]\r\n  var unknownType => $\"The vehicle type {unknownType} is not handled\", \/\/ var pattern\r\n  \/\/ _ => throw new InvalidOperationException(\"Vehicle is unknown\"), \/\/ Ce code est inatteignable \r\n};\r\n<\/code><\/pre>\n
Le motif var<\/i> est toujours vrai donc il est inutile de l’utiliser avec le motif discard<\/i>.\n<\/td>\n<\/tr>\n
Tuple pattern<\/b><\/td>\nC# 9<\/b><\/td>\nPour tester des conditions dans le cas de tuple<\/i> et d’une expression switch<\/code>.<\/b><\/p>\n
(int valueAsInt, string valueAsString, float valueAsFloat) tuple = (5, \"5\", 5f);\r\nstring result = tuple switch\r\n{\r\n  (5, \"5\", 5f) => \"All values are 5\",\r\n  (6, \"5\", 5f) => \"Int is 6\",\r\n  (7, \"7\", 7f) => \"All values are 7\",\r\n  (_, _, _) => \"No matches\", \/\/ Cas par d\u00e9faut \r\n};\r\n<\/code><\/pre>\n<\/td>\n<\/tr>\n
Positional pattern<\/b> avec un tuple<\/i><\/td>\nC# 9<\/b><\/td>\nOn utilise le caract\u00e8re _<\/code> si on ne veut pas que la condition s’applique \u00e0 un \u00e9l\u00e9ment d’un tuple<\/i>.<\/b><\/p>\n
(int valueAsInt, string valueAsString, float valueAsFloat) tuple = (5, \"5\", 5.0f);\r\nstring result = tuple switch\r\n{\r\n  (5, \"5\", 5.0f) => \"All values are equal\", \/\/ la condition porte sur tous les \u00e9l\u00e9ments\r\n  (5, _, _) => \"Ints are equal\",            \/\/ la condition porte seulement sur le 1er \u00e9l\u00e9ment\r\n  (_, \"5\", _) => \"Strings are equal\",       \/\/ la condition porte seulement sur le 2e \u00e9l\u00e9ment\r\n  (_, _, 5.0f) => \"Floats are equal\",       \/\/ la condition porte seulement sur le 3e \u00e9l\u00e9ment\r\n  (_, _, _) => \"No matches\",                \/\/ cas par d\u00e9faut\r\n};\r\n<\/code><\/pre>\n
On peut cr\u00e9er un nouveau tuple<\/i> pour l’utiliser dans l’expression et appliquer une condition avec when<\/code>:<\/p>\n
var tuple = (5, \"6\", 6f);\r\nstring result = tuple switch\r\n{\r\n  (5, \"5\", 5f) => \"All values are equal\",\r\n  (5, _, _) tupleWithSameInt => \r\n    $\"Ints are equal (string values are {tupleWithSameInt.Item2})\", \/\/ Utilisation du nouveau tuple dans l'expression\r\n  (_, _, _) matchingTuple<\/b> when matchingTuple.Item1 == 5 && matchingTuple.Item2 == \"6\" => \r\n    \"Ints and strings are equal\", \/\/ Utilisation du nouveau tuple avec une condition when\r\n  (_, _, _) => \"No matches\",\r\n};\r\n<\/code><\/pre>\n
Quelques d\u00e9tails sur les conditions utilis\u00e9es:<\/p>\n
    \n
  • (5, _, _) tupleWithSameInt<\/code>: la condition porte seulement sur le 1er<\/sup> \u00e9l\u00e9ment qui doit \u00eatre \u00e9gal \u00e0 5. Le tuple<\/i> tupleWithSameInt<\/code> est instanci\u00e9 et utilisable dans le reste de la condition si on utilise when<\/code> ou dans l’expression.<\/li>\n
  • On peut cr\u00e9er un nouveau tuple<\/i> contenant des \u00e9l\u00e9ments dont les noms sont diff\u00e9rents du tuple<\/i> d’origine.
    \nPar exemple, si on utilise la condition (var x, var y, var z) => $\"{x} {y} {z}\"<\/code>, on cr\u00e9e un tuple<\/i> dont les \u00e9l\u00e9ments sont nomm\u00e9s x<\/code>, y<\/code>, z<\/code> qui sont utilisable dans une condition when<\/code> et dans l’expression.<\/li>\n
  • On peut utiliser le caract\u00e8re discard<\/i> (i.e. _<\/code>) si on cr\u00e9e un nouveau type de tuple<\/i>.
    \nPar exemple, avec la condition (var x, _, _) => $\"{x}\"<\/code>. Le caract\u00e8re _<\/code> permet d’ignorer les autres \u00e9l\u00e9ments.<\/li>\n
  • Il n’est pas possible d’utiliser une condition avec un tuple<\/i> dont le nombre d’\u00e9l\u00e9ments n’est pas \u00e9gal \u00e0 celui du tuple<\/i> d’origine.
    \nPar exemple, la condition (var x, var y) => ...<\/code> provoque une erreur de compilation.<\/li>\n<\/ul>\n<\/td>\n<\/tr>\n
Relational pattern<\/b><\/td>\nC# 9<\/b><\/td>\nOn peut utiliser directement les op\u00e9rateurs ><\/code>, <<\/code>, >=<\/code> et <=<\/code> pour tester une condition.<\/b><\/p>\n
string text = vehicle.GetWheelCount() switch\r\n{\r\n  >= 4 => \"The vehicle is a car\",\r\n  <= 2 => \"The vehicle is a motobike\",\r\n  _ => throw new InvalidOperationException(\"Vehicle is unknown\"),\r\n};\r\n<\/code><\/pre>\n
Ce motif peut \u00eatre utilis\u00e9 en dehors d’une expression switch<\/code>.<\/p>\n
if (vehicle is Car { PassengerCount: <= 4 } car)\r\n{\r\n  \/\/ ...\r\n}\r\n<\/code><\/pre>\n
L’op\u00e9rateur ==<\/code> n’est pas utilisable, pour appliquer une condition d’\u00e9galit\u00e9, il suffit d’omettre l’op\u00e9rateur:<\/p>\n
string text = vehicle.GetWheelCount() switch\r\n{\r\n  4 => \"The vehicle is a car\",\r\n  2 => \"The vehicle is a motobike\",\r\n  _ => throw new InvalidOperationException(\"Vehicle is unknown\"),\r\n};\r\n<\/code><\/pre>\n<\/td>\n<\/tr>\n
Logical pattern<\/b><\/td>\nC# 9<\/b><\/td>\nPermet d’utiliser les op\u00e9rateurs and<\/code>, or<\/code> et not<\/code> pour tester des conditions.<\/b><\/p>\n
string text = vehicle.GetWheelCount() switch\r\n{\r\n  >= 4 and<\/u> <= 6 => \"The vehicle is a car\",\r\n  <= 2 and<\/u> > 0 => \"The vehicle is a motobike\",\r\n  _ => throw new InvalidOperationException(\"Vehicle is unknown\"),\r\n};\r\n\r\nstring text = vehicle switch\r\n{\r\n  null => \"not instanciated\",\r\n  not<\/u> null => \"instanciated\", \/\/ Op\u00e9rateur not\r\n};\r\n<\/code><\/pre>\n
Ce motif peut \u00eatre utilis\u00e9 en dehors d’une expression switch<\/code>.<\/p>\n
if (vehicle is Car { PassengerCount: >= 4 and <= 6 and not 5 } car)\r\n{\r\n  \/\/ ...\r\n}\r\n<\/code><\/pre>\n<\/td>\n<\/tr>\n
Property pattern<\/b><\/td>\nC# 10<\/b><\/td>\nPermet d’appliquer des conditions sur les propri\u00e9t\u00e9s des objets sans avoir une syntaxe trop lourde.<\/b><\/p>\n

Si on consid\u00e8re:<\/p>\n

public class Car\r\n{\r\n  public int PassengerCount;\r\n  public Engine Engine;\r\n}\r\n\r\npublic class Engine\r\n{\r\n  public string EngineType; \r\n  public int Horsepower; \r\n}\r\n<\/code><\/pre>\n
On peut \u00e9crire:<\/p>\n
string engineSize = vehicle switch\r\n{\r\n  Car { Engine.EngineType<\/u>: \"V8\" } => \"Big engine\",\r\n  Car { Engine.EngineType<\/u>: \"Straight-four\" } => \"Little engine\",\r\n  _ => \"No matches\"\r\n};\r\n<\/code><\/pre>\n
Avec une clause if<\/code>:<\/p>\n
if (vehicle is Car { Engine.EngineType: \"four stroke\" } car)\r\n{\r\n  \/\/ ...\r\n}\r\n<\/code><\/pre>\n<\/td>\n<\/tr>\n
List pattern<\/b><\/td>\nC# 11<\/b><\/td>\nPermet d’\u00e9noncer des conditions applicables sur les \u00e9l\u00e9ments d’une structure:<\/p>\n