Exercice - Créer une logique de décision avec des instructions if

19 minutes

La plupart des applications incluent un grand nombre de chemins d’exécution. Par exemple, une application peut implémenter différents chemins d’exécution en fonction de l’option de menu sélectionnée par l’utilisateur. Les développeurs parlent de branches de code pour faire référence au code qui implémente différents chemins d’exécution.

L’instruction la plus utilisée pour créer une branche de code est if. L’instruction if repose sur une expression booléenne qui est placée entre parenthèses. Si l’expression est vraie (true), le code après l’instruction if est exécuté. Si ce n’est pas le cas, le runtime .NET ignore le code et ne l’exécute pas.

Dans cet exercice, vous allez vous entraîner à écrire des instructions if en créant un jeu. Vous allez d’abord définir les règles du jeu, puis les implémenter dans le code.

Vous utiliserez la méthode Random.Next() pour simuler le lancer de trois dés à six faces. Vous évaluerez les valeurs des dés pour calculer le score. Si le score est supérieur à un total arbitraire, vous afficherez un message indiquant à l’utilisateur qu’il a gagné. Si le score est inférieur au seuil, vous afficherez un message indiquant à l’utilisateur qu’il a perdu.

Si deux des dés que vous lancez ont la même valeur, vous obtenez deux points bonus pour avoir fait un double.
Si les trois dés lancés ont la même valeur, vous obtenez six points bonus pour avoir fait un triple.
Si la somme des trois dés et des points bonus est supérieure ou égale à 15, vous avez gagné la partie. Sinon, vous avez perdu.

Vous affinerez les règles à mesure que vous en apprendrez plus sur l’instruction if.

Important

Cet exercice utilise largement la classe System.Random. Vous pouvez vous référer au module Microsoft Learn intitulé « Appeler des méthodes à partir de la bibliothèque de classes .NET en utilisant C# » si vous avez besoin d’actualiser vos connaissances concernant le fonctionnement de Random.Next().

Préparer votre environnement de programmation

Ce module comprend des activités qui vous guident tout au long du processus de création et d’exécution des exemples de code. 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.

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.
Dans Visual Studio Code, dans le menu Fichier, sélectionnez Ouvrir un dossier.
Dans la boîte de dialogue Ouvrir un dossier, accédez au dossier Bureau Windows.

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.
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.
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>
```
Notes

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 de cette série sur 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.
À 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.
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.
Dans Visual Studio Code, dans le menu Fichier, sélectionnez Ouvrir un dossier.
Dans la boîte de dialogue Ouvrir un dossier , sélectionnez le dossier CsharpProjects , puis sélectionnez Sélectionner un dossier.
Dans l’affichage EXPLORATEUR, développez le dossier TestProject, puis sélectionnez Program.cs.
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.
Fermez le panneau du Terminal.

Écrire du code qui génère trois nombres aléatoires et les affiche dans la sortie

Assurez-vous d’avoir un fichier Program.cs vide ouvert dans Visual Studio Code.

Pour créer le code initial de cet exercice, entrez ce qui suit :

Random dice = new Random();

int roll1 = dice.Next(1, 7);
int roll2 = dice.Next(1, 7);
int roll3 = dice.Next(1, 7);

int total = roll1 + roll2 + roll3;

Console.WriteLine($"Dice roll: {roll1} + {roll2} + {roll3} = {total}");

Prenez quelques instants pour passer en revue le code que vous avez entré.

Pour commencer, créez une instance de la classe System.Random et stockez une référence à l’objet dans une variable nommée dice. Ensuite, appelez la méthode Random.Next() sur l’objet dice à trois reprises, en fournissant les limites inférieure et supérieure pour que les valeurs possibles soient comprises entre 1 et 6 (la limite supérieure est exclusive). Vous enregistrez les trois nombres aléatoires dans les variables roll1, roll2 et roll3, respectivement.

Ensuite, vous additionnez les trois lancers de dés et enregistrez la valeur dans une variable entière nommée total.

Enfin, vous utilisez la méthode WriteLine() pour afficher les trois valeurs par interpolation de chaîne.

Lorsque vous exécutez le code, le message suivant doit s’afficher (les nombres seront différents).
```
Dice roll: 4 + 5 + 2 = 11
```
Cette première tâche était une tâche de configuration. À présent, vous pouvez ajouter la logique de décision à votre code pour rendre le jeu plus intéressant.

Ajouter une instruction if pour afficher des messages différents en fonction de la valeur de la variable du total

Dans l’Éditeur Visual Studio Code, localisez le curseur en bas de votre fichier de code, puis créez une ligne de code vide.
Pour créer votre première fonctionnalité de jeu, entrez les instructions if suivantes.
```
if (total > 14)
{
    Console.WriteLine("You win!");
}

if (total < 15)
{
    Console.WriteLine("Sorry, you lose.");
}
```
Ces deux instructions if permettent de gérer les scénarios de partie gagnée et de partie perdue. Prenez quelques instants pour examiner la première instruction if.

Notez que l’instruction if se compose de trois parties :
- Le mot clé if
- Une expression booléenne entre parenthèses ()
- Un bloc de code compris entre accolades { }
Au moment de l’exécution, l’expression booléenne total > 14 est évaluée. Si l’instruction est true (c’est-à-dire, si la valeur de total est supérieure à 14), l’exécution passe au code qui est défini dans le bloc de code. Autrement dit, il exécute le code compris entre accolades.

Toutefois, si l’expression booléenne est false (c’est-à-dire, si la valeur de total n’est pas supérieure à 14), l’exécution ignore le bloc de code. Autrement dit, il n’exécute pas le code compris entre accolades.

Enfin, la deuxième instruction if contrôle le message qui s’affiche si l’utilisateur perd la partie. Dans l’unité suivante, vous allez utiliser une variante de l’instruction if pour raccourcir ces deux instructions en une seule qui exprime plus clairement l’intention.

Qu’est-ce qu’une expression booléenne ?

Une expression booléenne est tout code qui retourne une valeur booléenne, true ou false. Les expressions booléennes les plus simples sont les valeurs true et false. Une expression booléenne peut également être le résultat d’une méthode qui retourne la valeur true ou false. Par exemple, voici un exemple de code simple qui utilise la méthode string.Contains() pour déterminer si une chaîne contient une autre chaîne.

string message = "The quick brown fox jumps over the lazy dog.";
bool result = message.Contains("dog");
Console.WriteLine(result);

if (message.Contains("fox"))
{
    Console.WriteLine("What does the fox say?");
}

Étant donné que message.Contains("fox") retourne une valeur true ou false, il est qualifié en tant qu’expression booléenne et peut être utilisé dans une instruction if.

D’autres expressions booléennes simples peuvent être créées à l’aide d’opérateurs permettant de comparer deux valeurs. Ces opérateurs sont les suivants :

==, l’opérateur « égal à » pour tester l’égalité
>, l’opérateur « supérieur à » pour vérifier que la valeur de gauche est supérieure à celle de droite
<, l’opérateur « inférieur à » pour vérifier que la valeur de gauche est inférieure à celle de droite
>=, l’opérateur « supérieur ou égal à »
<=, l’opérateur « inférieur ou égal à »
et ainsi de suite

Notes

La formation sur C# proposée par Microsoft Learn consacre un module entier aux expressions booléennes. De nombreux opérateurs peuvent être utilisés pour construire une expression booléenne. Toutefois, dans ce module, nous n’aborderons que les principaux. Pour plus d’informations sur les expressions booléennes, consultez le module Microsoft Learn intitulé « Évaluer des expressions booléennes pour prendre des décisions en C# ».

Dans cet exemple, vous avez évalué l’expression booléenne total > 14. Toutefois, vous auriez pu choisir l’expression booléenne total >= 15 puisque, dans ce cas, elles sont identiques. Étant donné que les règles du jeu spécifient que la partie est gagnée si la somme des trois dés, plus les points bonus, est supérieure ou égale à 15, il est préférable d’implémenter l’expression >= 15. Vous effectuerez ce changement à l’étape suivante de l’exercice.

Qu’est-ce qu’un bloc de code ?

Un bloc de code est une collection d’une ou de plusieurs lignes de code qui sont comprises entre une accolade ouvrante et une accolade fermante ({ }). Il constitue une unité de code complète qui a un objectif unique dans votre système logiciel. Dans ce cas, lors de l’exécution, toutes les lignes de code du bloc de code sont exécutées si l’expression booléenne a la valeur true. À l’inverse, si l’expression booléenne est fausse (false), toutes les lignes de code du bloc de code sont ignorées.

Vous devez également savoir que les blocs de code peuvent contenir d’autres blocs de code. En fait, il est courant qu’un bloc de code soit « imbriqué » dans un autre bloc de code d’une application. Vous commencerez à imbriquer vos propres blocs de code plus loin dans ce module quand vous créerez une instruction if dans le bloc de code d’une autre.

Notes

La formation sur C# proposée par Microsoft Learn consacre un module entier aux blocs de code. Les blocs de code sont essentiels pour comprendre l’organisation et la structure du code, et définissent les limites de la portée des variables. Pour plus d’informations sur les blocs de code, consultez le module intitulé « Étendue et logique des variables de contrôle à l’aide de blocs de code en C# ».

Ajouter une autre instruction if pour implémenter les points bonus d’un double

Ensuite, vous pouvez implémenter la règle suivante : « Si deux des dés que vous lancez ont la même valeur, vous obtenez deux points bonus pour avoir fait un double ». Modifiez le code de l’étape précédente pour qu’il corresponde à celui de la liste de codes suivante :

Dans l’Éditeur Visual Studio Code, localisez le curseur sur la ligne de code vide au-dessus de la première instruction if.
Pour créer la fonctionnalité de jeu « double », entrez l’instruction if suivante.
```
if ((roll1 == roll2) || (roll2 == roll3) || (roll1 == roll3))
{
    Console.WriteLine("You rolled doubles! +2 bonus to total!");
    total += 2;
}
```
Ici, vous combinez trois expressions booléennes pour créer une expression booléenne composite sur une seule ligne de code. C’est ce que nous appelons parfois une condition composée. Vous avez un jeu de parenthèses externes qui combine trois jeux de parenthèses internes, séparés par deux barres verticales.

Les deux barres verticales (||) correspondent à l’opérateur logique OU, qui indique ceci : « l’expression de gauche OU l’expression de droite doit être true pour que toute l’expression booléenne soit true ». Si les deux expressions booléennes sont false, l’expression booléenne entière est false. Vous utilisez deux opérateurs OU logiques pour étendre l’évaluation à une troisième expression booléenne.

Tout d’abord, vous évaluez (roll1 == roll2). Si sa valeur est true, l’expression entière est true. Si sa valeur est false, vous évaluez (roll2 == roll3). Si sa valeur est true, l’expression entière est true. Si sa valeur est false, vous évaluez (roll1 == roll3). Si sa valeur est true, l’expression entière est true. Si la valeur est false, l’expression entière est false.

Si l’expression booléenne composite est true, vous exécutez le bloc de code suivant. Cette fois-ci, il y a deux lignes de code. La première ligne de code affiche un message. La deuxième ligne de code incrémente la valeur de total de 2.
Pour améliorer la lisibilité de votre code, mettez à jour la deuxième instruction if comme suit :
```
if (total >= 15)
```
Notez que vous utilisez maintenant l’opérateur >= dans l’expression utilisée pour évaluer un lancer gagnant. L’opérateur >= signifie « supérieur ou égal à ». Par conséquent, vous pouvez comparer total à la valeur 15 plutôt qu’à la valeur 14. Avec ces modifications, l’expression que vous utilisez pour évaluer un lancer gagnant ressemble désormais à l’expression que vous évaluez pour un lancer perdant. Cela devrait rendre votre code plus facile à comprendre (plus lisible). Comme vous avez affaire à des valeurs entières, votre nouvelle expression (total >= 15) fonctionne de manière identique à ce que vous avez écrit précédemment : (total > 14).

Prenez quelques instants pour passer en revue votre code.

Votre code doit se présenter comme suit :

Random dice = new Random();

int roll1 = dice.Next(1, 7);
int roll2 = dice.Next(1, 7);
int roll3 = dice.Next(1, 7);

int total = roll1 + roll2 + roll3;

Console.WriteLine($"Dice roll: {roll1} + {roll2} + {roll3} = {total}");

if ((roll1 == roll2) || (roll2 == roll3) || (roll1 == roll3))
{
    Console.WriteLine("You rolled doubles! +2 bonus to total!");
    total += 2;
}

if (total >= 15)
{
    Console.WriteLine("You win!");
}

if (total < 15)
{
    Console.WriteLine("Sorry, you lose.");
}

Notez l’alignement amélioré entre les expressions utilisées pour évaluer les lancers gagnants et perdants.

Ajouter une autre instruction if pour implémenter les points bonus d’un triple

Ensuite, vous pouvez implémenter la règle suivante : « Si les trois dés lancés ont la même valeur, vous obtenez six points bonus pour avoir fait un triple ». Modifiez le code des étapes précédentes pour qu’il corresponde à celui de la liste de codes suivante :

Dans l’Éditeur Visual Studio Code, créez une ligne de code vide sous le bloc de code de votre instruction « double » if.
Pour créer la fonctionnalité de jeu « triple », entrez l’instruction if suivante.
```
if ((roll1 == roll2) && (roll2 == roll3)) 
{
    Console.WriteLine("You rolled triples! +6 bonus to total!");
    total += 6;
}
```
Ici, vous combinez deux expressions booléennes pour créer une expression booléenne composite sur une seule ligne de code. Vous avez un jeu de parenthèses externes qui combine deux jeux de parenthèses internes, séparés par deux esperluettes.

Les esperluettes doubles (&&) correspondent à l’opérateur logique ET, qui indique ceci : « si les deux expressions ont la valeur true, alors l’expression entière est true ». Dans ce cas, si roll1 est égal à roll2, et roll2 est égal à roll3, par déduction, roll1 doit être égal à roll3, ce qui signifie que l’utilisateur a fait un triple.
Dans le menu Fichier de Visual Studio Code, cliquez sur Enregistrer.

Prenez quelques instants pour passer en revue votre code.

Vérifiez que votre code correspond au suivant :

Random dice = new Random();

int roll1 = dice.Next(1, 7);
int roll2 = dice.Next(1, 7);
int roll3 = dice.Next(1, 7);

int total = roll1 + roll2 + roll3;

Console.WriteLine($"Dice roll: {roll1} + {roll2} + {roll3} = {total}");

if ((roll1 == roll2) || (roll2 == roll3) || (roll1 == roll3))
{
    Console.WriteLine("You rolled doubles! +2 bonus to total!");
    total += 2;
}

if ((roll1 == roll2) && (roll2 == roll3)) 
{
    Console.WriteLine("You rolled triples! +6 bonus to total!");
    total += 6;
}

if (total >= 15)
{
    Console.WriteLine("You win!");
}

if (total < 15)
{
    Console.WriteLine("Sorry, you lose.");
}

Dans l’affichage 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 doit s’ouvrir et doit inclure une invite de commandes indiquant que le Terminal est ouvert à l’emplacement de votre dossier TestProject.
À l’invite de commandes Terminal, pour exécuter votre code, tapez dotnet run, puis appuyez sur Entrée.

Notes

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>

Vous devriez voir une sortie similaire à l’un des résultats suivants :
```
Dice roll: 3 + 6 + 1 = 10
Sorry, you lose.
```
Ou ceci :
```
Dice roll: 1 + 4 + 4 = 9
You rolled doubles! +2 bonus to total!
Sorry, you lose.
```
Ou ceci :
```
Dice roll: 5 + 6 + 4 = 15
You win!
```
Si vous avez de la chance, vous verrez ceci :
```
Dice roll: 6 + 6 + 6 = 18
You rolled doubles! +2 bonus to total!
You rolled triples! +6 bonus to total!
You win!
```
Mais attendez, devez-vous vraiment récompenser un joueur pour avoir obtenu à la fois un triple et un double ? Après tout, l’obtention d’un triple implique celle d’un double. Dans l’idéal, les bonus ne doivent pas s’accumuler. Il doit y avoir deux conditions de bonus distinctes. Il s’agit d’un bogue dans la logique que vous devez corriger.

Problèmes dans votre logique et possibilités d’améliorer le code

Bien que ce soit un bon début et que vous ayez beaucoup appris sur l’instruction if, les expressions booléennes, les blocs de code, les opérateurs logiques OU et ET, etc., il y a beaucoup de choses à améliorer. Vous allez le faire dans la prochaine unité.

Récapitulatif

Utilisez une instruction if pour créer une branche dans la logique de votre code. L’instruction de décision if exécute du code dans son bloc de code si son expression booléenne a la valeur true. Si ce n’est pas le cas, le runtime ignore le bloc de code et continue jusqu’à la ligne de code qui vient après celui-ci.
Une expression booléenne est toute expression qui retourne une valeur booléenne.
Les opérateurs booléens comparent les valeurs de gauche et de droite pour tester leur égalité, et effectuer d’autres types de comparaisons.
Un bloc de code est compris entre accolades { }. Il rassemble des lignes de code qui doivent être traitées comme une unité.
L’opérateur logique ET && agrège deux expressions de sorte que les deux sous-expressions doivent avoir la valeur true pour que l’expression entière ait la valeur true.
L’opérateur logique OU || agrège deux expressions de sorte que si l’une des deux sous-expressions a la valeur true, l’expression entière a la valeur true.

Commentaires

Cette page a-t-elle été utile ?

Exercice - Créer une logique de décision avec des instructions if

Vérifiez vos connaissances

Commentaires