C# Language
Looping

Schleifenarten

Während

Der trivialste Schleifentyp. Der einzige Nachteil ist, dass es keinen intrinsischen Hinweis gibt, wo Sie sich in der Schleife befinden.

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

Tun

Ähnlich wie while , aber die Bedingung wird am Ende der Schleife anstatt am Anfang ausgewertet. Dies führt dazu, dass die Schleifen mindestens einmal ausgeführt werden.

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

Zum

Ein weiterer trivialer Loop-Stil. Während der Schleife wird ein Index ( i ) erhöht und Sie können ihn verwenden. Es wird normalerweise für die Handhabung von Arrays verwendet.

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

Für jeden

Modernisierte Methode zum Durchlaufen von IEnumarable Objekten. Gut, dass Sie nicht über den Index des Artikels oder die Anzahl der Elemente in der Liste nachdenken müssen.

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

Foreach-Methode

Während die anderen Stile zum Auswählen oder Aktualisieren der Elemente in Auflistungen verwendet werden, wird dieser Stil normalerweise für den sofortigen Aufruf einer Methode für alle Elemente in einer Auflistung verwendet.

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);

Es ist wichtig zu beachten, dass diese Methode nur für List<T> -Instanzen und als statische Methode für Array verfügbar ist - sie ist nicht Teil von Linq.

Linq Parallel Foreach

Genau wie Linq Foreach, außer dieser erledigt die Arbeit parallel. Das bedeutet, dass alle Elemente in der Sammlung gleichzeitig die angegebene Aktion ausführen.

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

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

brechen

Manchmal sollte der Schleifenzustand in der Mitte der Schleife überprüft werden. Ersteres ist wohl eleganter als das Letztere:

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
    }
}

Hinweis: In verschachtelten Schleifen und / oder switch muss mehr als nur eine einfache break .

Foreach-Schleife

Foreach wird jedes Objekt einer Klasse, die IEnumerable implementiert, IEnumerable (beachten Sie, dass IEnumerable<T> erbt). Zu diesen Objekten gehören einige eingebaute, sind jedoch nicht auf Dictionary<TKey, TSource> beschränkt: List<T> , T[] (Arrays eines beliebigen Typs), Dictionary<TKey, TSource> sowie Schnittstellen wie IQueryable und ICollection usw.

Syntax

foreach(ItemType itemVariable in enumerableObject)
    statement;

Bemerkungen

1. Der Typ ItemType muss nicht mit dem genauen Typ der Elemente übereinstimmen, sondern muss nur vom Typ der Elemente ItemType werden
2. Anstelle von ItemType kann alternativ var verwendet werden, um den IEnumerable aus dem IEnumerable , indem das generische Argument der IEnumerable Implementierung IEnumerable
3. Die Anweisung kann ein Block, eine einzelne Anweisung oder sogar eine leere Anweisung ( ; ) sein.
4. Wenn enumerableObject nicht Umsetzung IEnumerable , wird der Code nicht kompilieren
5. Während jeder Iteration wird das aktuelle Element in ItemType (auch wenn dies nicht angegeben ist, aber vom Compiler über var ) und wenn das Element nicht umgewandelt werden kann, wird eine InvalidCastException ausgelöst.

Betrachten Sie dieses Beispiel:

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

ist äquivalent zu:

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();
}

While-Schleife

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

Ausgabe:

0
1
2
3
4

IEnumerators können mit einer while-Schleife durchlaufen werden:

// 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);
}

Beispielausgabe:

Tokyo / Yokohama
New Yorker Metro
Sao Paulo
Seoul / Incheon

Für Schleife

A For Loop eignet sich hervorragend, um eine gewisse Zeit zu erledigen. Es ist wie eine While-Schleife, aber das Inkrement ist in der Bedingung enthalten.

Eine For-Schleife wird folgendermaßen eingerichtet:

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

Initialisierung - Erstellt eine neue lokale Variable, die nur in der Schleife verwendet werden kann.
Bedingung - Die Schleife wird nur ausgeführt, wenn die Bedingung erfüllt ist.
Inkrement - Wie sich die Variable bei jeder Ausführung der Schleife ändert.

Ein Beispiel:

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

Ausgabe:

0
1
2
3
4

Sie können auch Leerzeichen in der For-Schleife auslassen, aber Sie müssen alle Semikola haben, damit sie funktioniert.

int input = Console.ReadLine();    

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

Ausgabe für 3:

3
5
7
9
11

Do - While-Schleife

Sie ähnelt einer while Schleife, testet jedoch die Bedingung am Ende des Schleifenkörpers. Die Do-While-Schleife führt die Schleife einmal aus, unabhängig davon, ob die Bedingung erfüllt ist oder nicht.

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

Verschachtelte Schleifen

// 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);
    }
}

fortsetzen

Neben break gibt es auch das Schlüsselwort continue . Anstatt die Schleife vollständig zu unterbrechen, wird die aktuelle Iteration einfach übersprungen. Dies kann nützlich sein, wenn Sie nicht möchten, dass ein Code ausgeführt wird, wenn ein bestimmter Wert festgelegt ist.

Hier ist ein einfaches Beispiel:

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

    Console.WriteLine(i);
}

Wird darin enden, dass:

9
10

Hinweis: Continue ist während while- oder do-while-Schleifen oft am nützlichsten. For-Loops mit gut definierten Exit-Bedingungen profitieren möglicherweise weniger.