C# Language
En boucle

Styles de boucle

Tandis que

Le type de boucle le plus trivial. Le seul inconvénient est qu'il n'y a pas d'indice intrinsèque pour savoir où vous êtes dans la boucle.

/// loop while the condition satisfies
while(condition)
{
    /// do something
}

Faire

Semblable à while , mais la condition est évaluée à la fin de la boucle au lieu du début. Cela se traduit par l'exécution des boucles au moins une fois.

do
{
    /// do something
} while(condition) /// loop while the condition satisfies

Pour

Un autre style de boucle trivial. En boucle, un index ( i ) est augmenté et vous pouvez l'utiliser. Il est généralement utilisé pour manipuler des tableaux.

for ( int i = 0; i < array.Count; i++ )
{
    var currentItem = array[i];
    /// do something with "currentItem"
}

Pour chaque

IEnumarable modernisée de bouclage à travers les objets IEnumarable . Heureusement, vous n'avez pas à penser à l'index de l'élément ou au nombre d'éléments de la liste.

foreach ( var item in someList )
{
    /// do something with "item"
}

Méthode Foreach

Alors que les autres styles sont utilisés pour sélectionner ou mettre à jour les éléments dans les collections, ce style est généralement utilisé pour appeler une méthode immédiatement pour tous les éléments d'une collection.

list.ForEach(item => item.DoSomething());

// or
list.ForEach(item => DoSomething(item));

// or using a method group
list.ForEach(Console.WriteLine);

// using an array
Array.ForEach(myArray, Console.WriteLine);

Il est important de noter que cette méthode est uniquement disponible sur les instances List<T> et comme méthode statique sur Array - elle ne fait pas partie de Linq.

Linq Parallel Foreach

Tout comme Linq Foreach, sauf que celui-ci fait le travail en parallèle. Cela signifie que tous les éléments de la collection exécuteront l'action donnée simultanément, simultanément.

collection.AsParallel().ForAll(item => item.DoSomething());

/// or
collection.AsParallel().ForAll(item => DoSomething(item));

Pause

Parfois, la condition de la boucle doit être vérifiée au milieu de la boucle. Le premier est sans doute plus élégant que le second:

for (;;)
{
    // precondition code that can change the value of should_end_loop expression

    if (should_end_loop)
        break;

    // do something
}

Alternative:

bool endLoop = false;
for (; !endLoop;)
{
    // precondition code that can set endLoop flag

    if (!endLoop)
    {
        // do something
    }
}

Remarque: dans les boucles imbriquées et / ou le switch doit utiliser plus qu'une simple break .

Boucle Foreach

foreach itérera sur tout objet d'une classe qui implémente IEnumerable (notez que IEnumerable<T> hérite). De tels objets incluent des objets intégrés, mais ne se limitent pas à: List<T> , T[] (tableaux de tout type), Dictionary<TKey, TSource> , ainsi que des interfaces comme IQueryable et ICollection , etc.

syntaxe

foreach(ItemType itemVariable in enumerableObject)
    statement;

remarques

1. Le type ItemType n'a pas besoin de correspondre au type précis des éléments, il doit simplement être assignable à partir du type des éléments
2. Au lieu de ItemType , var peut aussi être utilisé pour déduire le type d'éléments de l'énumerableObject en inspectant l'argument générique de l'implémentation IEnumerable
3. L'instruction peut être un bloc, une seule instruction ou même une instruction vide ( ; )
4. Si enumerableObject pas IEnumerable , le code ne sera pas compilé
5. Au cours de chaque itération, l'élément en cours est ItemType en ItemType (même s'il n'est pas spécifié, mais via le var via le compilateur) et si l'élément ne peut pas être InvalidCastException une InvalidCastException sera lancée.

Considérez cet exemple:

var list = new List<string>();
list.Add("Ion");
list.Add("Andrei");
foreach(var name in list)
{
    Console.WriteLine("Hello " + name);
}

est équivalent à:

var list = new List<string>();
list.Add("Ion");
list.Add("Andrei");
IEnumerator enumerator;
try
{
    enumerator = list.GetEnumerator();
    while(enumerator.MoveNext())
    {
        string name = (string)enumerator.Current;
        Console.WriteLine("Hello " + name);
    }
}
finally
{
    if (enumerator != null)
        enumerator.Dispose();
}

En boucle

int n = 0;
while (n < 5) 
{
    Console.WriteLine(n);
    n++;
}

Sortie:

0
1
2
3
4

Les IEnumerators peuvent être itérés avec une boucle while:

// Call a custom method that takes a count, and returns an IEnumerator for a list
// of strings with the names of theh largest city metro areas.
IEnumerator<string> largestMetroAreas = GetLargestMetroAreas(4);

while (largestMetroAreas.MoveNext())
{
    Console.WriteLine(largestMetroAreas.Current);
}

Sortie de l'échantillon:

Tokyo / Yokohama
Métro de New York
Sao Paulo
Séoul / Incheon

Pour boucle

Une boucle For est idéale pour faire les choses un certain temps. C'est comme une boucle While mais l'incrément est inclus dans la condition.

Une boucle For est configurée comme ceci:

for (Initialization; Condition; Increment)
{
    // Code
}

Initialisation - Crée une nouvelle variable locale qui ne peut être utilisée que dans la boucle.
Condition - La boucle ne s'exécute que lorsque la condition est vraie.
Incrément - Comment la variable change à chaque exécution de la boucle.

Un exemple:

for (int i = 0; i < 5; i++)
{
    Console.WriteLine(i);
}

Sortie:

0
1
2
3
4

Vous pouvez également laisser des espaces dans la boucle For, mais vous devez avoir tous les points-virgules pour que cela fonctionne.

int input = Console.ReadLine();    

for ( ; input < 10; input + 2)
{
    Console.WriteLine(input);
}

Sortie pour 3:

3
5
7
9
11

Boucle Do-While

Il est semblable à un while en boucle, à l' exception qu'il teste la condition à la fin du corps de la boucle. La boucle Do-While exécute la boucle une seule fois, que la condition soit vraie ou non.

int[] numbers = new int[] { 6, 7, 8, 10 };
    
// Sum values from the array until we get a total that's greater than 10,
// or until we run out of values.
int sum = 0;
int i = 0;
do
{
    sum += numbers[i];
    i++;
} while (sum <= 10 && i < numbers.Length);
    
System.Console.WriteLine(sum); // 13

Boucles imbriquées

// Print the multiplication table up to 5s
for (int i = 1; i <= 5; i++)
{
    for (int j = 1; j <= 5; j++)
    {
        int product = i * j;
        Console.WriteLine("{0} times {1} is {2}", i, j, product);
    }
}

continuer

En plus de break , il y a aussi le mot clé continue . Au lieu de casser complètement la boucle, il faudra simplement ignorer l'itération en cours. Cela pourrait être utile si vous ne voulez pas qu'un code soit exécuté si une valeur particulière est définie.

Voici un exemple simple:

for (int i = 1; i <= 10; i++)
{
    if (i < 9)
        continue;

    Console.WriteLine(i);
}

Aura pour résultat:

9
10

Remarque: Continue est souvent utile dans les boucles while ou do-while. Les boucles For, avec des conditions de sortie bien définies, pourraient ne pas en bénéficier autant.