Les boucles

Une autre technique essentielle lorqu'on écrit un programme sont les boucles - la possibilité de répéter un bloque de code X fois. En C#, ils en existent 4 types, et nous allons voir chaque type en détail.

La boucle while

La boucle while est propablement la plus simple, c'est pourquoi nous commencons par elle. Elle permet d'exécuter un bloque de code aussi longtemps que la condition donnée est vraie. Un petit exemple suivit de plus d'explications :

using System;

namespace ConsoleApplication1
{
    class Program
    {
    static void Main(string[] args)
    {
        int number = 0;

        while(number < 5)
        {
        Console.WriteLine(number);
        number = number + 1;
        }

        Console.ReadLine();
    }
    }
}

Essayez d'executer ce code. Vous allez obtenir une belle suite de nombres, de 0 à 4. La variable "number" est d'abords définie à 0, et à chaque execution du code dans la boucle, on lui ajoute 1. Alors pourquoi est-ce que la suite s'arrête à 4 alors que le code dit 5? Pour que la condition retourne vrai, la variable number doit-être inférieure à 5, donc dans notre cas le code qui écrit en sortie la variable number n'est pas atteint lorsqu'elle est égale à 5. Et ceux car la condition de la boucle while est évaluée avant d'entrer dans le bloque de code.

La boucle do

Pour une boucle do c'est le contraire, la condition est évaluée à la fin de la séquence d'instruction. Une boucle do s'exécutera donc toujours au moins une fois. Pour le reste cette boucle fonctionne exactement comme une boucle while.

int number = 0;
do  
{  
    Console.WriteLine(number);  
    number = number + 1;  
} while(number < 5);

Cependant le résultat est le même : une fois que la variable number est supérieure à 5, on sort de la boucle.

La boucle for

La boucle for est un peu différente. Elle est surtout utilisé lorsque l'on connait le nombre d'itérations voulues, soit parce qu'on connait le nombre exact d'itérations, soit parce que l'on a une variable contenant ce nombre. Ci-dessous un exemple de boucle for.

using System;

namespace ConsoleApplication1
{
    class Program
    {
    static void Main(string[] args)
    {
        int number = 5;

        for(int i = 0; i < number; i++)
        Console.WriteLine(i);

        Console.ReadLine();
    }
    }
}

On obtient le même résultat en sortie, mais comme vous pouvez le voir, la boucle for est un peu plus compacte. Elle est constituée de 3 parties : on initialise une variable pour compter, met en place une instruction conditionnelle pour la tester, et on incrémente le compteur(++ est équivalent à "variable = variable + 1").

La première partie est exécutée une seule fois avant que la boucle commence, c'est ici que l'on déclare la variable i et qu'elle est initialisée à 0. Les deux autres parties sont exécutées à chaque itération. A chaque tour, la variable i est comparée à la variable "number". Si i est strictement plus petit que "number", la boucle s'exécute une fois de plus. A la fin d'un tour, la variable i est incrémentée de 1.

Essayez d'exécuter ce programme, puis essayez de changer la variable "number" en augmentant ou diminuant sa valeur. Le comportement de la boucle répondra à ce changement.

La boucle "pourchaque" (foreach)

La dernier déclinaison de boucle que nous allons voir est la boucle "PourChaque" (en anglais, foreach). Cette boucle opère sur des collections d’objets, par exemple un tableau ou autre type de liste. Dans notre exemple, nous allons utiliser le type ArrayList faisant partie des cas les plus simples. Son fonctionnement ressemble beaucoup au tableau, mais ne vous inquiétez pas, ce type sera abordé plus tard.

using System;
using System.Collections;

namespace ConsoleApplication1
{
    class Program
    {
    static void Main(string[] args)
    {        
        ArrayList list = new ArrayList();
        list.Add("John Doe");
        list.Add("Jane Doe");
        list.Add("Someone Else");
        
        foreach(string name in list)
        Console.WriteLine(name);

        Console.ReadLine();
    }
    }
}

OK, maintenant que nous avons créé une instance d'une ArrayList, nous allons y mettre quelques éléments String. Nous utiliserons la boucle foreach pour parcourir chaque élément, affectant le nom de la variable à l'élément que nous avons atteint à chaque fois. Ainsi, nous aurons une variable nommée à chaque fois. Comme vous pouvez le constater, nous déclarons le nom de la variable comme étant de type String - vous devez toujours dire à la boucle foreach quelle type de données vous vous attendez à récupérer de la collection. Dans le cas où vous avez des listes de type variable, vous pourriez utiliser la classe object à la place d'une classe précise, et ainsi récupérer chaque élément comme un object générique.

Lorsque que vous travaillerez avec des collections, vous utiliserez la plus part du temps les boucles foreach. La principale raison est qu'elle est la plus simple pour le parcours de collection.