Exercice - Créer des boucles d’itération do et while

10 minutes

À première vue, les instructions do-while et while sont encore une autre instruction de parcours qui vous permet de parcourir un bloc de code et ainsi modifier le flux d'exécution de votre code. Toutefois, une fois que nous examinons le fonctionnement de chaque instruction, nous pouvons mieux identifier les nuances de chaque instruction d’itération et quand les utiliser.

Qu’est-ce que l’instruction do-while ?

L’instruction do-while exécute une instruction ou un bloc d’instructions pendant qu’une expression booléenne spécifiée prend la valeur true. Étant donné que cette expression est évaluée après chaque exécution de la boucle, une boucle do-while s’exécute une ou plusieurs fois.

do
{
    // This code executes at least one time
} while (true);

Le flux d’exécution commence à l’intérieur de l’accolade. Le code s’exécute au moins une fois, puis l’expression booléenne en regard du while mot clé est évaluée. Si l’expression booléenne retourne true, le bloc de code est réexécuté.

En codant en dur l'expression booléenne à true, nous avons créé une boucle infinie, une boucle qui ne se terminera jamais, du moins, pas dans la manière dont elle est actuellement écrite. Nous aurions besoin d’un moyen de sortir de la boucle à l’intérieur du bloc de code. Nous allons aborder les critères de sortie d’un do-while d'ici peu.

Ok, nous allons maintenant préparer notre environnement de codage et commencer notre examen des exemples de code qui implémentent une do-while instruction.

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.

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 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.
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>
```
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.
À 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 une instruction do-while pour arrêter lorsqu’un certain nombre aléatoire est généré

Nous allons écrire du code qui continuera à générer des nombres aléatoires compris entre 1 et 10 jusqu’à ce que nous générions le nombre 7. Il peut prendre une seule itération pour obtenir un 7, ou il peut prendre des dizaines d’itérations.

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.

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

Random random = new Random();
int current = 0;

do
{
    current = random.Next(1, 11);
    Console.WriteLine(current);
} while (current != 7);

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.
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.
À 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>
Passez en revue votre résultat.

Étant donné que les nombres générés sont aléatoires, vos résultats seront différents. Toutefois, la valeur 7 sera le dernier nombre à imprimer, car l’expression booléenne sera évaluée false à la date de génération 7 et le flux d’exécution quittera le bloc de code.
```
2
5
8
2
7
```
Prenez quelques instants pour passer en revue votre code.

Un apprentissage clé pour cette première tâche est que le bloc de code d’une do-while boucle s’exécute au moins une fois. Il pourrait itérer un grand nombre de fois, et il est peu probable que nous savons à l’avance combien d’itérations il y aura.

Il est également important de noter que le code à l’intérieur du bloc de code influence s’il faut continuer à itérer via le bloc de code ou non. Un bloc de code qui influence les critères de sortie est une raison principale de sélectionner une instruction do-while ou while plutôt que l'une des autres instructions d'itération. Les foreach et for dépendent de facteurs externes au bloc de code pour déterminer le nombre d’itérations du bloc de code.

Écrire une instruction while qui itère uniquement lorsqu’un nombre aléatoire est supérieur à une valeur

Examinons à présent l’instruction while.

Utilisez Visual Studio Code Editor pour mettre à jour votre code comme suit :
```
Random random = new Random();
int current = random.Next(1, 11);

/*
do
{
    current = random.Next(1, 11);
    Console.WriteLine(current);
} while (current != 7);
*/

while (current >= 3)
{
    Console.WriteLine(current);
    current = random.Next(1, 11);
}
Console.WriteLine($"Last number: {current}");
```
Remarque

Dans ce cas, nous positionlons le while mot clé et l’expression booléenne avant le bloc de code. Cela modifie la signification du code et agit comme une « porte » pour autoriser uniquement le flux d’exécution à entrer si l’expression booléenne prend la valeur true.
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.
Passez en revue les valeurs de sortie répertoriées.

Étant donné que les nombres sont aléatoires, votre code produit une séquence différente.
```
9
7
5
Last number: 1
```
Prenez quelques instants pour passer en revue votre code.

En haut du code, nous utilisons random pour initialiser notre int variable nommée current. Notre prochaine ligne de code active est notre while déclaration.

Notre while instruction itérera en fonction de l’expression (current >= 3)booléenne . Nous ne savons pas à quelle valeur sera affectée current, mais il existe des possibilités qui affectent notre while boucle :
- Si current est initialisé à une valeur supérieure ou égale à 3, l’expression booléenne retournera true, et le flux d’exécution entrera dans le bloc de code. Dans le bloc de code, la première chose que nous faisons d'abord est d’écrire la valeur de current sur la console. Ensuite, toujours à l’intérieur du bloc de code, nous mettons à jour la valeur de current par une nouvelle valeur aléatoire. À ce stade, le contrôle revient en haut de l’instruction while où l’expression booléenne est évaluée. Ce processus se poursuit jusqu’à ce que l’expression booléenne retourne false et que le flux d’exécution s’arrête du bloc de code.
- Si current est initialisé (en haut de notre code) à une valeur inférieure à 3, alors l'expression booléenne retournera false, et le bloc de code ne s'exécutera jamais.
La ligne de code finale écrit la valeur de current à la console. Ce code s’exécute que le bloc de code d’itération ait été exécuté ou non, et c'est notre chance d’écrire la valeur finale de current à la console.

Utiliser l’instruction continue pour effectuer une étape directement vers l’expression booléenne

Dans certains cas, nous voulons court-circuiter le reste du code dans le bloc de code et passer à l’itération suivante. Nous pouvons le faire à l’aide de l’instruction continue .

Utilisez Visual Studio Code Editor pour mettre à jour votre code comme suit :

Random random = new Random();
int current = random.Next(1, 11);

do
{
    current = random.Next(1, 11);

    if (current >= 8) continue;

    Console.WriteLine(current);
} while (current != 7);

/*
while (current >= 3)
{
    Console.WriteLine(current);
    current = random.Next(1, 11);
}
Console.WriteLine($"Last number: {current}");
*/

Prenez quelques instants pour passer en revue votre code.

Notez que nous sommes renvoyés à une instruction do-while. Une do-while garantie que la boucle itérera au moins une fois.

La première chose que nous faisons à l’intérieur du bloc de code consiste à affecter une nouvelle valeur aléatoire à current. Ensuite, nous vérifions si current est supérieur ou égal à 8. Si cette expression retourne true, le mot-clé continue transfèrera le contrôle à la fin du bloc de code et while évaluera (current != 7). Ainsi, la boucle continuera à itérer tant que la valeur de current n’est pas égale à 7.

La clé de cette étape de l’exercice est la ligne de code contenant le continue mot clé :
```
if (current >= 8) continue;
```
Étant donné que notre code qui écrit la valeur de current à la console se trouve après le if (current >= 8) continue;, notre code garantit qu'une valeur de current qui est supérieure ou égale à 8 ne sera jamais écrite dans la fenêtre de résultats.

Essayons ça.
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.
Passez en revue les valeurs de sortie répertoriées.
```
5
1
6
7
```
Vous verrez probablement des résultats différents de ceux affichés ci-dessous. Toutefois, vous ne verrez aucune valeur 8 ni plus dans la fenêtre de sortie avant que l’exécution du code se termine par la valeur 7.
Tenez compte de la différence entre les instructions continue et break.

Comme vous l’avez vu dans cette dernière étape, l’instruction continue transfère l’exécution à la fin de l’itération actuelle. Ce comportement est différent du comportement que nous avons vu avec l’instruction break . L’instruction break met fin à l’itération (ou switch) et transfère le contrôle à l’instruction qui suit l’instruction terminée. S’il n’y a pas d’instruction après l’instruction terminée, le contrôle est transféré à la fin du fichier ou de la méthode.

Récapitulatif

Il y a quelques idées importantes que vous devez retirer de cette unité :

L’instruction do-while effectue une itération au sein d’un bloc de code au moins une fois et peut continuer à itérer en fonction d’une expression booléenne. L’évaluation de l’expression booléenne dépend généralement d’une valeur générée ou récupérée à l’intérieur du bloc de code.
L’instruction while évalue d’abord une expression booléenne et continue d’effectuer une itération dans le bloc de code tant que l’expression booléenne prend truela valeur .
Le mot clé continue permet de passer immédiatement à l’expression booléenne.

Commentaires

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

Exercice - Créer des boucles d’itération do et while

Vérification des connaissances

Commentaires