C# Switch Expression Explained : Un guide pratique de Tim Corey

Expression traditionnelle If-Else vs. expression Switch

Tim commence par une application console dans laquelle une variable int nommée numberGrade contient une note d'examen comme 85. L'objectif est de convertir cette valeur numérique d'entrée en une lettre de note correspondante, telle que "B". Dans la plupart des cas, les développeurs utilisent une série d'instructions if-else ou une instruction switch, comme celle-ci :

if (numberGrade >= 90)
    letterGrade = "A";
else if (numberGrade >= 80)
    letterGrade = "B";
// ...and so on

if (numberGrade >= 90)
    letterGrade = "A";
else if (numberGrade >= 80)
    letterGrade = "B";
// ...and so on

Cette méthode fonctionne, mais elle est verbeuse. Les expressions de commutation en C#, en revanche, offrent une syntaxe plus propre.

Écrire une expression de commutation pour la notation

Pour démontrer une expression de commutation, Tim réécrit la logique ci-dessus à l'aide du code suivant :

string letterGrade = numberGrade switch
{
    >= 90 => "A",
    >= 80 => "B",
    >= 70 => "C",
    >= 60 => "D",
    _ => "F"
};

string letterGrade = numberGrade switch
{
    >= 90 => "A",
    >= 80 => "B",
    >= 70 => "C",
    >= 60 => "D",
    _ => "F"
};

Ici, le mot-clé switch est utilisé dans un nouveau contexte : il s'agit d'une expression et non d'une déclaration. Cela signifie qu'il évalue directement une valeur et peut être assigné à une variable (comme letterGrade).

Ce formulaire prend en charge les modèles relationnels (par exemple, >= 90) et utilise le modèle de rejet (_) pour traiter le cas par défaut, qui est équivalent à la finale else.

Tim note que le compilateur détermine la correspondance au moment de l'exécution, en vérifiant chaque condition de haut en bas et en choisissant le premier modèle qui correspond à l'entrée.

Simplifier le code avec des expressions

Selon Tim, cette nouvelle syntaxe "remplace tout un tas de code" Au lieu de répéter les conditions avec else if, l'expression switch gère tout dans une structure claire et concise. Cela simplifie le flux de contrôle, améliore la lisibilité et réduit la redondance dans votre logique.

Il souligne que cette structure est particulièrement utile lorsqu'il s'agit de faire correspondre des valeurs d'entrée à des sorties spécifiques, telles que le classement, les messages d'état ou la transformation des données.

Utilisation de la correspondance des motifs avec les types d'objets

Pour explorer les modèles de type et la correspondance des modèles, Tim présente un scénario impliquant une interface IAnimal. Il définit trois classes - Dog, Cat et Cow - qui implémentent chacune l'interface. Cela lui permet de créer une liste d'animaux, chacun ayant des propriétés différentes.

interface IAnimal { }

record Dog(string Name) : IAnimal;
record Cat(string Title, string Name) : IAnimal;
record Cow(string Breed) : IAnimal;

interface IAnimal { }

record Dog(string Name) : IAnimal;
record Cat(string Title, string Name) : IAnimal;
record Cow(string Breed) : IAnimal;

Il remplit une liste avec diverses instances d'animaux et montre comment utiliser la correspondance des types pour identifier le type d'objet et extraire les données.

Expression de commutation avec correspondance de motifs

Tim montre comment le code suivant utilise les instructions if :

if (a is Dog d)
    message = $"Dog: {d.Name}";
else if (a is Cat c)
    message = $"Cat: {c.Title} {c.Name}";
else if (a is Cow co)
    message = $"Cow: {co.Breed}";
else
    message = "Unknown animal";

if (a is Dog d)
    message = $"Dog: {d.Name}";
else if (a is Cat c)
    message = $"Cat: {c.Title} {c.Name}";
else if (a is Cow co)
    message = $"Cow: {co.Breed}";
else
    message = "Unknown animal";

Peut être remplacé par une expression de commutation beaucoup plus compacte et lisible :

string message = a switch
{
    Dog d => $"Dog: {d.Name}",
    Cat c => $"Cat: {c.Title} {c.Name}",
    Cow co => $"Cow: {co.Breed}",
    _ => "Unknown animal"
};

string message = a switch
{
    Dog d => $"Dog: {d.Name}",
    Cat c => $"Cat: {c.Title} {c.Name}",
    Cow co => $"Cow: {co.Breed}",
    _ => "Unknown animal"
};

Cette expression vérifie le type de l'objet et applique la sortie correcte en fonction du modèle trouvé. Si aucune correspondance n'est trouvée, elle revient à un résultat par défaut à l'aide de la fonction discard (rejeter).

Cette caractéristique améliore la fonctionnalité sans sacrifier la clarté. Le comportement de l'exécution reste prévisible et lisible.

Gardes optionnelles avec le mot-clé when

Bien que cela ne soit pas démontré dans l'exemple de Tim, il est important de noter que les expressions switch peuvent être étendues avec le mot-clé when pour appliquer une condition booléenne optionnelle :

int score = 90;

string result = score switch
{
    int s when s >= 90 && s <= 100 => "Excellent",
    int s when s >= 75 => "Good",
    _ => "Needs Improvement"
};

int score = 90;

string result = score switch
{
    int s when s >= 90 && s <= 100 => "Excellent",
    int s when s >= 75 => "Good",
    _ => "Needs Improvement"
};

Ici, la clause when permet une évaluation personnalisée de l'argument, en utilisant des expressions booléennes plus complexes.

Bonnes pratiques et réflexions finales

Tim met l'accent sur un concept essentiel : si les expressions switch rendent votre code plus compact, compact n'est pas toujours synonyme de meilleur. Parfois, en particulier lorsque la logique est complexe ou que les entrées ne sont pas claires, une instruction switch traditionnelle ou un bloc if peuvent être plus appropriés.

Il n'est pas nécessaire d'utiliser une expression de commutation dans tous les cas : utilisez l'outil approprié. Il ne s'agit pas d'adhérer à la "secte du switch", comme le dit Tim en plaisantant. Il s'agit d'écrire un code facile à maintenir et à comprendre dans votre système.

Résumé : Ajouter des expressions de commutation à votre boîte à outils de développeur

Les expressions de commutation C# offrent un moyen moderne et propre d'évaluer et de renvoyer des valeurs basées sur des modèles d'entrée, en utilisant une combinaison de modèles constants, relationnels et de type. Ces traductions sont idéales lorsque vous souhaitez simplifier la logique, réduire les formules passe-partout et améliorer la lisibilité.

Qu'il s'agisse de classer des nombres entiers ou d'identifier des objets animaux, les exemples suivants de la vidéo de Tim Corey mettent en évidence leurs utilisations pratiques. Que vous construisiez une fonction pour calculer des résultats, que vous gériez des entrées utilisateur ou que vous travailliez avec des cas null et undefined, les expressions switch peuvent vous aider à gagner du temps, à réduire les erreurs et à rendre votre base de code plus facile à gérer.

Comme le dit Tim, "ils constituent un outil très utile à avoir dans sa boîte à outils pour rendre son code plus simple et plus propre, tout en restant aussi compréhensible, voire plus."

Si vous cherchez à améliorer la qualité de votre code C# et à suivre les innovations de .NET Core, ne faites pas l'impasse sur les expressions de commutation. Essayez-les, expérimentez-les dans vos projets Visual Studio et voyez à quel point votre logique peut devenir plus propre.