C# For-Schleife & foreach: Die C# Schleifen im Überblick

Oft müssen wir den gleichen Quellcode für mehrere Anwendungsfälle ausführen. Dafür sind Schleifen, insbesondere die C# For-Schleife, äußerst hilfreich. Deswegen möchte ich im folgenden Artikel die Verwendung der for und foreach Schleifen in C# erklären.

Die C# for-Schleife

for ist eine der am häufigsten anzufindenden Schleifen in höheren Programmiersprachen. Die grundsätzliche Verwendung dieser funktioniert in etwa so:

for (Initialisierung; Bedingung; Wertveränderung) {
    // auszuführender Quellcode
}

Praktisch kannst du damit Code schreiben, der nur so lange ausgeführt wird, wie die definierte Bedingung zutrifft. Wenn du eine Anweisung schreiben wolltest, die nur drei Mal ausgeführt wird, könntest du wie folgt vorgehen:

for (int i = 0; i < 3; i++) {
    Console.WriteLine($"i ist {i}");
}

i ist 0
i ist 1
i ist 2

Dabei wird mit int i = 0; eine neue Integervariablemit dem Wert 0 initialisiert.
Mit i < 3; wird bei jedem Durchlauf überprüft, ob die Variable i kleiner als 3 ist.
Mit i++; wird der Wert von i nach jedem Durchlauf um 1 erhöht.

Vorsicht: Endlose C# For-Schleifen

Theoretisch könntest du auch alle diese Angaben weglassen, was allerdings in einer Endlosschleife resultiert.
Wenn du folgendes tust, wird dein Programm so lange Hello World! in der Konsole ausgeben, bis es von außen abgebrochen wird:

for (; ; ) {
    Console.WriteLine("Hello World!");
}

Ablauf der C# For-Schleife mit break und continue manipulieren

break lässt dich die Ausführung einer Schleife abbrechen. break lässt sich sehr gut im Zusammenhang mit einer weiteren Überprüfung wie einem if-Statement kombinieren. Das folgende Beispiel legt die Variable i als 2 fest und verdoppelt i bei jedem Durchlauf.

for (int i = 2; i < 1024; i = i*2) {
    Console.WriteLine($"i = {i}");
    if (i == 16) {
        Console.WriteLine("Ausführung wird abgebrochen");
        break;
    }
}

i = 2
i = 4
i = 8
i = 16
Ausführung wird abgebrochen

Mit continue kannst du die Ausführung der darauffolgenden Anweisungen unterbinden und die Schleife mit der nächsten Iteration fortführen.

for (int i = 2; i < 64; i = i*2) {
    if (i == 16) {
        Console.WriteLine("Wert wird übersprungen");
        continue;
    }
    Console.WriteLine($"i = {i}");
}

i = 2
i = 4
i = 8
Wert wird übersprungen
i = 32

Auf Elemente von Arrays mit einer For-Schleife zugreifen

Da du auf einzelne Elemente von Arrays mit ihrem Index zugreifen kannst und dieses 0-basiert ist, kannst du ganz einfach auf jedes Element zugreifen. Dazu musst du nur eine Variable mit dem Wert 0 initialisieren und diese bei jeder Ausführung um 1 erhöhen.  Du solltest die Schleife beenden, wenn deine Variable nicht mehr kleiner ist als die Länge des Arrays ist!

int[] int_array = {2, 4, 8, 16};
for (int i = 0; i < int_array.Length; i++) {
    Console.WriteLine($"index: {i}, wert: {int_array[i]}");
}

index: 0, wert: 2
index: 1, wert: 4
index: 2, wert: 8
index: 3, wert: 16

Verschachtelte For-Schleifen in C#

Ebenfalls ist es möglich, eine Schleife innerhalb einer Schleife zu konstruieren.

for (int i = 1; i < 4; i++) {
    Console.WriteLine($"i = {i}");
    for (int j = i; j < 3; j++) {
        Console.WriteLine($"j = {j}");
    }
}

i = 1
j = 1
j = 2
i = 2
j = 2
i = 3

Das vorige Beispiel hat erst für jede Iteration der ersten Schleife den Wert von i ausgegeben. Danach wurde eine neue Schleife ausgeführt, in der die Variable j mit dem Wert von i initialisiert wurde.
Diese wurde dann ausgegeben und für die nächste Iteration um 1 erhöht.

Mehrere Ausdrücke in einer C# For-Schleife

Du kannst innerhalb einer for-Schleife auch mehrere Ausdrücke angeben. Das folgende Beispiel initialisiert die Variablen i und j und erhöht diese jeweils um 1, wenn eine Iteration der Schleife abgeschlossen wurde.

for (int i = 0, j = 1; i + j < 6; i++, j++) {
    Console.WriteLine($"i = {i}, j = {j}");
}

i = 0, j = 1
i = 1, j = 2
i = 2, j = 3

Das C# foreach

foreach bietet eine einfache Möglichkeit, auf alle Elemente eines Arrays oder anderer Ansammlungen von Werten zuzugreifen.

foreach (Datentyp Variablenname in Sammlung_von_Werten) {
     // auszuführender Quellcode
}

Einfache Anwendung des foreach

Du kannst mit foreach einfach auf jedes Element eines Arrays zugreifen, indem du den Typ der Elemente und den Namen, unter dem du auf sie zugreifen willst, angibst.

int[] int_array = { 2, 4, 8, 16 };
foreach (int i in int_array) {
    Console.WriteLine($"i = {i}");
}

i = 2
i = 4
i = 8
i = 16

Dasselbe gilt auch für Listen. Die hier definierte Beispielliste wird auch für die folgenden Beispiele verwendet.

List<int> int_list = new List<int>();
int_list.Add(2);
int_list.Add(4);
int_list.Add(8);
int_list.Add(16);
foreach (int i in int_list){
    Console.WriteLine(i);
}

2
4
8
16

Ablauf des foreach mit break und continue manipulieren

Auch hier können wir mit break die Ausführung weiterer Iterationen durch foreach verhindern.

int[] int_array = { 2, 4, 8, 16 };
foreach (int i in int_array) {
    if (i == 8) {
        break;
    }
    Console.WriteLine($"i = {i}");
}

i = 2
i = 4

continue lässt sich ebenfalls erneut anwenden, um die aktuelle Iteration zu verkürzen.

foreach (int i in int_list){
    if (i == 8) {
        continue;
    }
    Console.WriteLine(i);
}

2
4
16

Die Methode ForEach

Array und List implementieren beide die Methode ForEach. Diese kannst du ebenfalls verwenden, um mit jedem Element einer Auflistung eine Aktion durchzuführen. Dafür musst du den Typen, das Array selbst und eine Funktion oder Methode, die die auszuführende Aktion repräsentiert, übergeben. Im folgenden Beispiel wird mit ForEach ein Array aus Integern durchlaufen.

int[] int_array = { 2, 4, 8, 16 };
Array.ForEach<int>(int_array, delegate(int i) {
    Console.WriteLine(i);
});

2
4
8
16

Im letzten Code-Ausschnitt haben wir die auszuführende Aktion mit delegate übergeben. Eine weitere Möglichkeit, eine Methode an ForEach zu übergeben, ist Action.

Für unsere nächsten Beispiele verwenden wir die hier definierte Methode WriteInt.

static void WriteInt(int i) {
    Console.WriteLine(i);
}

Diese können wir nun mit Action wie folgt übergeben:

Action<int> action = new Action<int>(WriteInt);
int_list.ForEach(action);

Bei Listen kann die Methode ForEach auf Objekte dieser angewendet werden.

int_list.ForEach(delegate (int i) {
    Console.WriteLine(i);
});

2
4
8
16

Hierfür kannst du ebenfalls mit Action eine Methode übergeben.

Action<int> action = new Action<int>(WriteInt);
int_list.ForEach(action);

Fazit

Mit for und foreach bietet uns C# zwei sehr wichtige Möglichkeiten, um viele Anweisungen nacheinander auszuführen. break und continue lassen uns den Schleifenablauf beider zu unseren Gunsten manipulieren

Hast du noch Anmerkungen, Fragen, Lob oder Verbesserungsvorschläge? Schreib es bitte in die Kommentare.