Boucle C# while et do...while

C# while et do...while loop

Dans cet article, nous allons découvrir les boucles while et do...while en C#, comment les utiliser et leur différence.

En programmation, on souhaite souvent exécuter un certain bloc d'instructions un certain nombre de fois. Une solution possible consistera à taper ces instructions le nombre de fois requis. Cependant, le nombre de répétitions peut ne pas être connu à l'avance (au moment de la compilation) ou être suffisamment grand (disons 10 000).

La meilleure solution à ce problème est la boucle. Les boucles sont utilisées en programmation pour exécuter de manière répétée un certain bloc d'instructions jusqu'à ce qu'une condition soit remplie.

Dans cet article, nous allons apprendre à utiliser les boucles while en C#.

C# boucle while

Le pendant que Le mot-clé est utilisé pour créer une boucle while en C#. La syntaxe de la boucle while est :

while (test-expression)
{
	// body of while
}

Comment fonctionne la boucle ?

La boucle while C# consiste en un test-expression .
Si le test-expression est évalué à true ,
1. les instructions à l'intérieur de la boucle while sont exécutées.
2. après exécution, le test-expression est à nouveau évalué.
Si le test-expression est évalué à false , la boucle while se termine.

Organigramme de la boucle while

Exemple 1 :boucle while

using System;

namespace Loop
{
	class WhileLoop
	{
		public static void Main(string[] args)
		{
			int i=1;
			while (i<=5)
			{
				Console.WriteLine("C# For Loop: Iteration {0}", i);
				i++;
			}
		}
	}
}

Lorsque nous exécutons le programme, la sortie sera :

C# For Loop: Iteration 1
C# For Loop: Iteration 2
C# For Loop: Iteration 3
C# For Loop: Iteration 4
C# For Loop: Iteration 5

Initialement la valeur de i est 1.

Lorsque le programme atteint l'instruction de la boucle while,

l'expression de test i <=5 est évalué. Depuis je vaut 1 et 1 <= 5 est true , il exécute le corps de la boucle while. Ici, la ligne est imprimée à l'écran avec Itération 1, et la valeur de i est augmenté de 1 pour devenir 2.
Maintenant, l'expression de test (i <=5 ) est à nouveau évalué. Cette fois aussi, l'expression renvoie true (2 <=5), donc la ligne est imprimée à l'écran et la valeur de i est maintenant incrémenté à 3..
Cela continue et la boucle while s'exécute jusqu'à i devient 6. À ce stade, l'expression de test sera évaluée à false et donc la boucle se termine.

Exemple 2 :boucle while pour calculer la somme des 5 premiers nombres naturels

using System;

namespace Loop
{
	class WhileLoop
	{
		public static void Main(string[] args)
		{
			int i=1, sum=0;

			while (i<=5)
			{
				sum += i;
				i++;
			}
			Console.WriteLine("Sum = {0}", sum);
		}
	}
}

Lorsque nous exécutons le programme, la sortie sera :

Sum = 15

Ce programme calcule la somme des 5 premiers nombres naturels.

Initialement la valeur de sum est initialisé à 0.
A chaque itération, la valeur de sum est mis à jour à sum+i et la valeur de i est incrémenté de 1.
Lorsque la valeur de i atteint 6, l'expression de test i<=5 renverra false et la boucle se terminera.

Voyons ce qui se passe dans le programme donné à chaque itération.

Initialement, je =1, somme =0

Étapes d'exécution de la boucle While
Itération	Valeur de i	i<=5	Valeur de la somme
1	1	vrai	0+1 =1
2	2	vrai	1+2 =3
3	3	vrai	3+3 =6
4	4	vrai	6+4 =10
5	5	vrai	10+5 =15
6	6	faux	La boucle se termine

Ainsi, la valeur finale de sum aura 15 ans.

C# faire...boucle while

Le faire et pendant mot clé est utilisé pour créer une boucle do...while. Elle est similaire à une boucle while, mais il existe une différence majeure entre elles.

Dans la boucle while, la condition est vérifiée avant l'exécution du corps. C'est exactement le contraire dans la boucle do...while, c'est-à-dire que la condition est vérifiée après l'exécution du corps.

C'est pourquoi, le corps de la boucle do...while s'exécutera au moins une fois indépendamment de l'expression de test.

La syntaxe de la boucle do...while est :

do
{
	// body of do while loop
} while (test-expression);

Comment fonctionne la boucle while ?

Le corps de la boucle do...while est exécuté en premier.
Puis le test-expression est évalué.
Si le test-expression est true , le corps de la boucle est exécuté.
Lorsque le test-expression est false , do...while boucle se termine.

organigramme de la boucle do...while

Exemple 3 :boucle do...while

using System;

namespace Loop
{
	class DoWhileLoop
	{
		public static void Main(string[] args)
		{
			int i = 1, n = 5, product;

			do
			{
				product = n * i;
				Console.WriteLine("{0} * {1} = {2}", n, i, product);
				i++;
			} while (i <= 10);
		}
	}
}

Lorsque nous exécutons le programme, la sortie sera :

5 * 1 = 5
5 * 2 = 10
5 * 3 = 15
5 * 4 = 20
5 * 5 = 25
5 * 6 = 30
5 * 7 = 35
5 * 8 = 40
5 * 9 = 45
5 * 10 = 50

Comme nous pouvons le voir, le programme ci-dessus imprime la table de multiplication d'un nombre (5).

Initialement, la valeur de i vaut 1. Le programme entre alors dans le corps de la boucle do..while sans vérifier aucune condition (contrairement à la boucle while).
À l'intérieur du corps, produit est calculé et imprimé à l'écran. La valeur de i est ensuite incrémenté à 2.
Après l'exécution du corps de la boucle, l'expression de test i <= 10 est évalué. Au total, la boucle do...while sera exécutée 10 fois.
Enfin, lorsque la valeur de i est 11, l'expression de test est évaluée à false et termine donc la boucle.

Boucle infinie while et do...while

Si l'expression de test dans la boucle while et do...while n'est jamais évaluée à false , le corps de la boucle s'exécutera indéfiniment. De telles boucles sont appelées boucle infinie.

Par exemple :

Boucle while infinie

while (true)
{
	// body of while loop
}

Boucle infinie do...while

do
{
	// body of while loop
} while (true);

La boucle infinie est utile lorsque nous avons besoin qu'une boucle s'exécute tant que notre programme s'exécute.

Par exemple, si votre programme est une animation, vous devrez l'exécuter constamment jusqu'à ce qu'il soit arrêté. Dans de tels cas, une boucle infinie est nécessaire pour continuer à exécuter l'animation à plusieurs reprises.

Opérateur C# ternaire (? :) C# pour la boucle

Langue C