Exercice - Implémenter une instruction switch

Une switch instruction est une instruction de sélection C# qui offre une alternative à une if-elseif-else construction de branchement. L’instruction switch offre des avantages par rapport à une if-elseif-else construction lors de l’évaluation d’une valeur unique par rapport à une liste de valeurs correspondantes connues.

Considérez le scénario suivant :

• Vous travaillez sur une application liée à la nutrition alimentaire. Une section du code traite des fruits.
• Votre code inclut une variable nommée fruit utilisée pour contenir le nom de différents types de fruits.
• Vous avez une liste des 20 fruits sur lesquels votre application est ciblée.
• Vous souhaitez créer une branche de votre code en fonction de la valeur affectée à fruit.

Dans ce scénario, vous pouvez utiliser une switch instruction pour créer une branche distincte pour chaque type de fruit.

Comment fonctionne une instruction switch ?

L’instruction switch choisit une section de code à exécuter dans une liste de sections de commutateur possibles. Cette section switch est choisie en fonction d’une correspondance de modèle avec l’expression de correspondance de l’instruction.

Considérez l’exemple de code suivant qui montre la structure de base de l’instruction switch :

switch (fruit)
{
    case "apple":
        Console.WriteLine($"App will display information for apple.");
        break;

    case "banana":
        Console.WriteLine($"App will display information for banana.");
        break;

    case "cherry":
        Console.WriteLine($"App will display information for cherry.");
        break;
}

L’expression de correspondance (qui peut également être appelée expression switch) est la valeur qui suit le switch mot clé, dans ce cas (fruit). Chaque section de commutateur est définie par un modèle de cas. Les modèles de cas sont construits à l’aide du mot clé case suivi d’une valeur. Le premier modèle de cas dans cet exemple est : case "apple":. Les modèles de cas sont des expressions booléennes qui s’évaluent soit à true soit à false. Chaque section switch inclut un petit nombre de lignes de code qui seront exécutées si le modèle de cas correspond à l’expression de correspondance. Dans cet exemple, si la valeur « apple » est affectée à fruit, le premier modèle de cas est évalué comme true et cette section switch est exécutée.

Une instruction switch doit inclure au moins une section switch, mais comprend habituellement trois sections switch ou plus.

Le commutateur est le mieux utilisé lorsque :

• Vous disposez d’une valeur unique (variable ou expression) que vous souhaitez mettre en correspondance avec de nombreuses valeurs possibles.
• Pour une correspondance donnée, vous ne souhaitez pas exécuter plus de quelques lignes de code.

Il est temps de préparer votre environnement de codage et de commencer à développer vos propres switch instructions.

Préparer votre environnement de programmation

Ce module comprend des activités pratiques qui vous guident tout au long du processus de création et d’exécution du code de démonstration. Nous vous encourageons à effectuer ces activités à l’aide de Visual Studio Code comme environnement de développement. L’utilisation de Visual Studio Code pour ces activités vous permet d’être plus à l’aise dans l’écriture et l’exécution de code dans un environnement de développement qui est utilisé par les professionnels du monde entier.

1. Ouvrez Visual Studio Code.

   Vous pouvez utiliser le menu Démarrer de Windows (ou une ressource équivalente pour un autre système d’exploitation) pour ouvrir Visual Studio Code.

2. Dans Visual Studio Code, dans le menu Fichier, sélectionnez Ouvrir un dossier.

3. Dans la boîte de dialogue Ouvrir le dossier , accédez au dossier Windows Desktop.

   Si vous conservez vos projets de code dans un autre dossier, vous pouvez utiliser cet emplacement à la place. Pour cette formation, l’important est d’avoir un emplacement facile à localiser et à mémoriser.

4. Dans la boîte de dialogue Ouvrir un dossier, sélectionnez Sélectionner un dossier.

   Si une boîte de dialogue de sécurité vous demande si vous faites confiance aux auteurs, sélectionnez Oui.

5. Dans le menu Terminal de Visual Studio Code, sélectionnez Nouveau Terminal.

   Notez qu’une invite de commandes dans le panneau Terminal affiche le chemin du dossier actif. Par exemple:

   C:\Users\someuser\Desktop>
   

   Remarque

   Si vous travaillez sur votre propre PC plutôt que dans un bac à sable ou un environnement hébergé et que vous avez terminé d’autres modules Microsoft Learn dans cette série C#, vous avez peut-être déjà créé un dossier de projet pour les exemples de code. Si c’est le cas, vous pouvez passer à l’étape suivante, qui est utilisée pour créer une application console dans le dossier TestProject.

6. À l’invite de commandes terminal, pour créer une application console dans un dossier spécifié, entrez l’invite suivante :

   dotnet new console -o ./CsharpProjects/TestProject
   

   Cette commande CLI .NET utilise un modèle de programme .NET pour créer un projet d’application console C# à l’emplacement du dossier spécifié. La commande crée les dossiers CsharpProjects et TestProject automatiquement, et utilise TestProject comme nom pour votre fichier .csproj.

   Si un message s’affiche pour vous indiquer que les fichiers existent déjà, passez aux étapes suivantes. Vous allez réutiliser les fichiers projet existants.

7. Dans l’affichage EXPLORATEUR, développez le dossier CsharpProjects .

   Vous devez voir le dossier TestProject et deux fichiers, un fichier de programme C# nommé Program.cs et un fichier projet C# nommé TestProject.csproj.

8. Dans Visual Studio Code, dans le menu Fichier, sélectionnez Ouvrir un dossier.

9. Dans la boîte de dialogue Ouvrir un dossier , sélectionnez le dossier CsharpProjects , puis sélectionnez Sélectionner un dossier.

10. Dans l’affichage EXPLORATEUR, développez le dossier TestProject, puis sélectionnez Program.cs.

11. Supprimez les lignes de code existantes.

    Vous allez utiliser ce projet de console C# pour créer, générer et exécuter des exemples de code au cours de ce module.

12. Fermez le panneau du Terminal.

Créer et tester une instruction switch

1. Vérifiez que Visual Studio Code est ouvert et que Program.cs est affiché dans le panneau d’édition.

   Remarque

   Program.cs doit être vide. Si ce n’est pas le cas, sélectionnez toutes les lignes de code et supprimez-les.

2. Tapez le code suivant dans l’Éditeur Visual Studio Code :

   int employeeLevel = 200;
   string employeeName = "John Smith";
   
   string title = "";
   
   switch (employeeLevel)
   {
       case 100:
           title = "Junior Associate";
           break;
       case 200:
           title = "Senior Associate";
           break;
       case 300:
           title = "Manager";
           break;
       case 400:
           title = "Senior Manager";
           break;
       default:
           title = "Associate";
           break;
   }
   
   Console.WriteLine($"{employeeName}, {title}");
   

3. Dans le menu Fichier de Visual Studio Code, sélectionnez Enregistrer.

   Le fichier Program.cs doit être enregistré avant de générer ou d’exécuter le code.

4. Dans le panneau EXPLORATEUR, pour ouvrir un Terminal à l’emplacement de votre dossier TestProject, cliquez avec le bouton droit sur TestProject, puis sélectionnez Ouvrir dans le Terminal intégré.

   Un panneau Terminal s’ouvre. Le Terminal doit inclure une invite de commandes indiquant qu’il est ouvert à l’emplacement de votre dossier TestProject.

5. À l’invite de commande du terminal, pour exécuter votre code, tapez dotnet run, puis appuyez sur Entrée.

   Remarque

   Si vous voyez un message indiquant « Impossible de trouver un projet à exécuter », vérifiez que l’invite de commandes Terminal affiche l’emplacement attendu du dossier TestProject. Par exemple : C:\Users\someuser\Desktop\csharpprojects\TestProject>

   La sortie suivante doit s’afficher :

   John Smith, Senior Associate
   

6. Prenez une minute pour passer en revue l’instruction switch que vous avez entrée.

7. Notez que l’instruction switch définit un bloc de code unique.

   L’instruction switch définit un bloc de code unique qui inclut une liste de sections switch. À droite du switch mot clé est une expression switch placée entre parenthèses.

8. Observez la liste de sections switch dans le bloc de code.

   Le switch bloc de code contient une liste de sections de commutateur, chacune incluant une ou plusieurs étiquettes de commutateur. En outre, chaque section switch inclut une liste d’instructions qui s’exécute si l’étiquette est égale à l’expression switch définie en haut de l’instruction switch.

   L’expression de switch est évaluée par rapport aux étiquettes case de haut en bas jusqu’à ce qu’une valeur correspondant à l’expression de switch soit trouvée. Si aucune étiquette ne correspond, la liste d’instructions pour le cas default est exécutée. Si aucune valeur par défaut n’est incluse, le contrôle est transféré vers le point de terminaison de l’instruction switch. Chaque étiquette doit fournir un type valeur qui correspond au type spécifié dans l’expression switch.

   Remarque

   L’étiquette facultative default peut apparaître à n’importe quelle position dans la liste des sections switch. Toutefois, la plupart des développeurs choisissent de le mettre en dernier, car il est plus logique (logiquement) de positionner default comme option finale. Quelle que soit la position, la default section sera évaluée en dernier.

   Dans notre exemple :

   • l’expression switch est (employeeLevel)
   • chaque section de commutateur a une étiquette de commutateur unique (case ou default).
   • la section de commutateur correspondant est définie par case: 200, depuis employeeLevel = 200.

9. Notez que chaque section de commutateur est séparée de la suivante.

   Vous ne pouvez exécuter qu’une seule section switch. Cela signifie que l’exécution d’une section switch interdit tout passage à la section switch suivante. Le break mot clé est l’une des différentes façons de mettre fin à une section switch avant d’accéder à la section suivante. Si vous oubliez le mot clé break (ou éventuellement le mot clé return), le compilateur génère une erreur.

Modifiez la valeur de variable de niveau pour voir comment l’instruction switch l’évalue

Pour exercer le cas par défaut, nous allons modifier le niveau de l’employé en modifiant l’affectation de valeur.

1. Pour modifier la valeur affectée à employeeLevel, mettez à jour votre code comme suit :

   int employeeLevel = 201;
   

2. Enregistrez votre fichier de code, puis utilisez Visual Studio Code pour exécuter votre code.

   Entrez dotnet run à partir de l’invite de commandes du Terminal pour exécuter votre code.

3. Notez que la sortie a changé.

   Maintenant, lorsque vous exécutez le code, vous devez voir le titre plus générique utilisé.

   John Smith, Associate
   

   Étant donné que l’étiquette employeeLevel ne correspond à aucune étiquette, l’étiquette default est correspondante.

Modifier une section de commutateur pour inclure plusieurs étiquettes

Supposons que notre entreprise a décidé de donner à tous les employés de niveau 100 le titre « Senior Associate » ( le même titre que celui des 200 employés de niveau 200). En tant que développeur, vous décidez d'implémenter cela en supprimant la première section switch appartenant à l'étiquette case 100:, et en permettant aux étiquettes case 100: et case 200: d'exécuter la même section switch.

1. Pour modifier la valeur affectée à employeeLevel, mettez à jour votre code comme suit :

   int employeeLevel = 100;
   

2. Pour affecter plusieurs étiquettes à la première section switch, mettez à jour votre code comme suit :

   case 100:
   case 200:
       title = "Senior Associate";
       break;
   

   Lorsque vous avez terminé d’apporter des modifications, vos modifications doivent correspondre au code suivant :

   int employeeLevel = 100;
   string employeeName = "John Smith";
   
   string title = "";
   
   switch (employeeLevel)
   {
       case 100:
       case 200:
           title = "Senior Associate";
           break;
       case 300:
           title = "Manager";
           break;
       case 400:
           title = "Senior Manager";
           break;
       default:
           title = "Associate";
           break;
   }
   
   Console.WriteLine($"{employeeName}, {title}");
   

3. Enregistrez votre fichier de code, puis utilisez Visual Studio Code pour exécuter votre code.

   Entrez dotnet run à partir de l’invite de commandes du Terminal pour exécuter votre code.

   La sortie suivante doit s’afficher :

   John Smith, Senior Associate
   

   Les deux étiquettes case 100 et 200 sont maintenant associées à la section switch qui définit le titre avec la valeur de chaîne Senior Associate.

Récapitulatif

Voici les principaux enseignements que nous pouvons tirer de l’instruction switch :

• Utilisez l’instruction switch lorsque vous avez une valeur avec de nombreuses correspondances possibles, chaque correspondance nécessitant une branche dans votre logique de code.
• Une section de commutateur unique contenant la logique de code peut être mise en correspondance à l’aide d’une ou plusieurs étiquettes définies par le case mot clé.
• Utilisez le mot clé facultatif default pour créer une étiquette et une section switch à utiliser quand aucune autre étiquette case ne correspond.