Zum Hauptinhalt springen

Schleifen

for-Schleifen​

for-Schleifen in C# werden verwendet, um eine bestimmte Anzahl von Schleifendurchläufen durchzuführen. Die Syntax für eine for-Schleife lautet:

for (initialisierung; bedingung; inkrement/dekrement)
{
    // Anweisungen, die in jeder Schleifendurchlauf ausgeführt werden sollen
}

Der initialisierung-Teil der Schleife wird einmal ausgeführt, bevor die Schleife beginnt. In der Regel wird hier eine Variable initialisiert, die in der Schleife verwendet wird.

Die bedingung wird zu Beginn jedes Schleifendurchlaufs geprüft. Wenn die Bedingung true ergibt, wird der Schleifenkörper ausgeführt. Wenn die Bedingung false ergibt, wird die Schleife beendet.

Das inkrement/dekrement wird nach jedem Schleifendurchlauf ausgeführt. In der Regel wird hier die Variable inkrementiert oder dekrementiert, die in der Schleife verwendet wird.

Hier ist ein Beispiel, das die Verwendung einer for-Schleife veranschaulicht:

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

In diesem Beispiel wird eine for-Schleife verwendet, um fünf Schleifendurchläufe auszuführen. Die Variable i wird initialisiert und auf 0 gesetzt. Die Bedingung i < 5 wird zu Beginn jedes Schleifendurchlaufs geprüft. Solange i kleiner als 5 ist, wird der Schleifenkörper ausgeführt. Nach jedem Schleifendurchlauf wird i inkrementiert.

Der Schleifenkörper gibt eine Nachricht aus, die den aktuellen Schleifendurchlauf angibt. Nach fünf Schleifendurchläufen wird die Schleife beendet.

Eine for-Schleife kann auch verwendet werden, um über ein Array zu iterieren:

int[] zahlen = { 1, 2, 3, 4, 5 };

for (int i = 0; i < zahlen.Length; i++)
{
    Console.WriteLine(zahlen[i]);
}

In diesem Beispiel wird ein Array zahlen mit fünf Elementen initialisiert. Eine for-Schleife wird verwendet, um über das Array zu iterieren. Die Variable i wird initialisiert und auf 0 gesetzt. Die Bedingung i < zahlen.Length wird zu Beginn jedes Schleifendurchlaufs geprüft. Solange i kleiner als die Länge des Arrays ist, wird der Schleifenkörper ausgeführt. Nach jedem Schleifendurchlauf wird i inkrementiert.

Der Schleifenkörper gibt jedes Element des Arrays aus. Nachdem alle Elemente ausgegeben wurden, wird die Schleife beendet.

Schleifen beenden mit break​

Das break-Schlüsselwort in C# wird verwendet, um eine Schleife vorzeitig zu beenden. Wenn das break-Schlüsselwort in einer Schleife ausgeführt wird, wird die Schleife sofort beendet und die Ausführung des Codes wird fortgesetzt, der nach der Schleife kommt.

Hier ist ein Beispiel, das die Verwendung von break in einer for-Schleife veranschaulicht:

for (int i = 0; i < 10; i++)
{
    if (i == 5)
    {
        break;
    }
    Console.WriteLine("Schleifendurchlauf {0}", i);
}
Console.WriteLine("Schleife beendet");

In diesem Beispiel wird eine for-Schleife verwendet, um 10 Schleifendurchläufe auszuführen. In jedem Schleifendurchlauf wird geprüft, ob i gleich 5 ist. Wenn i gleich 5 ist, wird die break-Anweisung ausgeführt und die Schleife wird vorzeitig beendet. Wenn i nicht gleich 5 ist, wird der Schleifenkörper ausgeführt und die Nachricht "Schleifendurchlauf" zusammen mit dem aktuellen Wert von i wird ausgegeben.

Nachdem die Schleife beendet wurde, wird die Nachricht "Schleife beendet" ausgegeben.

Das break-Schlüsselwort kann auch in anderen Schleifentypen wie while- und do-while-Schleifen verwendet werden, um die Schleife vorzeitig zu beenden, wenn eine bestimmte Bedingung erfüllt ist.

Continue in Schleifen​

Das continue-Schlüsselwort in C# wird verwendet, um den aktuellen Schleifendurchlauf zu beenden und mit dem nächsten Durchlauf fortzufahren. Wenn das continue-Schlüsselwort in einer Schleife ausgeführt wird, werden alle Anweisungen im Schleifenkörper, die nach dem continue-Schlüsselwort stehen, übersprungen und die Schleife geht direkt zum nächsten Schleifendurchlauf über.

Hier ist ein Beispiel, das die Verwendung von continue in einer for-Schleife veranschaulicht:

for (int i = 0; i < 10; i++)
{
    if (i % 2 == 0)
    {
        continue;
    }
    Console.WriteLine("Ungerade Zahl: {0}", i);
}

In diesem Beispiel wird eine for-Schleife verwendet, um 10 Schleifendurchläufe auszuführen. In jedem Schleifendurchlauf wird geprüft, ob i eine gerade Zahl ist. Wenn i eine gerade Zahl ist, wird die continue-Anweisung ausgeführt und der restliche Schleifenkörper wird übersprungen. Wenn i eine ungerade Zahl ist, wird die Nachricht "Ungerade Zahl" zusammen mit dem aktuellen Wert von i ausgegeben.

Beachten Sie, dass die Anweisungen im Schleifenkörper, die nach dem continue-Schlüsselwort stehen, übersprungen werden, aber die Schleife selbst wird nicht beendet. Die Schleife geht einfach zum nächsten Schleifendurchlauf über.

Das continue-Schlüsselwort kann auch in anderen Schleifentypen wie while- und do-while-Schleifen verwendet werden, um den aktuellen Schleifendurchlauf zu beenden und mit dem nächsten Durchlauf fortzufahren.

foreach-Schleifen​

Die foreach-Schleife in C# wird verwendet, um eine Schleife durch alle Elemente in einem Array oder einer anderen Auflistung (z.B. einer Liste oder eines Dictionaries) auszuführen. Der Vorteil der foreach-Schleife besteht darin, dass Sie sich keine Gedanken über den Zugriff auf Elemente über einen Index machen müssen, da die Schleife automatisch durch jedes Element in der Auflistung iteriert.

Hier ist ein Beispiel für die Verwendung einer foreach-Schleife:

int[] zahlen = { 1, 2, 3, 4, 5 };
foreach (int zahl in zahlen)
{
    Console.WriteLine(zahl);
}

In diesem Beispiel wird eine foreach-Schleife verwendet, um durch jedes Element im zahlen-Array zu iterieren und den Wert jedes Elements auf der Konsole auszugeben. Beachten Sie, dass wir hier keinen Index verwenden, um auf jedes Element zuzugreifen, sondern stattdessen das zahl-Schlüsselwort verwenden, um auf jedes Element zuzugreifen.

Sie können die foreach-Schleife auch mit anderen Arten von Auflistungen verwenden, z.B. mit Listen oder Dictionaries. Hier ist ein Beispiel für die Verwendung einer foreach-Schleife mit einer List<string>:

List<string> namen = new List<string> { "Max", "Anna", "Tom" };
foreach (string name in namen)
{
    Console.WriteLine(name);
}

In diesem Beispiel wird eine List<string> verwendet, um eine Liste von Namen zu speichern. Die foreach-Schleife wird verwendet, um durch jede Zeichenfolge in der Liste zu iterieren und den Wert jeder Zeichenfolge auf der Konsole auszugeben.

while-Schleife​

Die while-Schleife in C# wird verwendet, um eine Schleife auszuführen, solange eine bestimmte Bedingung erfüllt ist. Die Schleife führt den Codeblock innerhalb der Schleife aus, solange die Bedingung wahr ist.

Hier ist ein Beispiel für die Verwendung einer while-Schleife:

int i = 0;
while (i < 5)
{
    Console.WriteLine("Die Zahl ist: " + i);
    i++;
}

In diesem Beispiel wird eine while-Schleife verwendet, um den Wert von i zu erhöhen und den Text "Die Zahl ist:" zusammen mit dem aktuellen Wert von i auf der Konsole auszugeben. Die Schleife wird so lange ausgeführt, wie der Wert von i kleiner als 5 ist.

Es ist wichtig zu beachten, dass die Bedingung in der while-Schleife wahr sein muss, damit der Code innerhalb der Schleife ausgeführt wird. Wenn die Bedingung bereits zu Beginn falsch ist, wird der Code innerhalb der Schleife niemals ausgeführt.

Sie können die while-Schleife auch mit booleschen Ausdrücken verwenden, um eine Schleife zu erstellen, die nur dann ausgeführt wird, wenn eine bestimmte Bedingung wahr ist. Hier ist ein Beispiel:

bool bedingung = true;
while (bedingung)
{
    Console.WriteLine("Die Bedingung ist wahr!");
    bedingung = false;
}

In diesem Beispiel wird die while-Schleife so lange ausgeführt, wie die Bedingung bedingung wahr ist. Der Code innerhalb der Schleife gibt den Text "Die Bedingung ist wahr!" auf der Konsole aus und ändert dann den Wert von bedingung auf false, um sicherzustellen, dass die Bedingung in der nächsten Schleifeniteration falsch ist.

do-Schleife​

Die do-while-Schleife in C# ist eine Schleifenkonstruktion, die verwendet wird, um eine Anweisungssequenz auszuführen, solange eine Bedingung wahr ist. Der Unterschied zur while-Schleife besteht darin, dass die Bedingung am Ende der Schleife geprüft wird, was bedeutet, dass der Code innerhalb der Schleife mindestens einmal ausgeführt wird, unabhängig davon, ob die Bedingung wahr ist oder nicht.

Hier ist ein Beispiel für die Verwendung einer do-while-Schleife:

int i = 0;
do
{
    Console.WriteLine("Die Zahl ist: " + i);
    i++;
} while (i < 5);

In diesem Beispiel wird eine do-while-Schleife verwendet, um den Wert von i zu erhöhen und den Text "Die Zahl ist:" zusammen mit dem aktuellen Wert von i auf der Konsole auszugeben. Die Schleife wird mindestens einmal ausgeführt, da die Bedingung i < 5 erst am Ende der Schleife geprüft wird. Wenn die Bedingung wahr ist, wird der Code innerhalb der Schleife erneut ausgeführt.

Es ist wichtig zu beachten, dass die do-while-Schleife immer mindestens einmal ausgeführt wird, da die Bedingung am Ende der Schleife geprüft wird. Wenn die Bedingung bereits zu Beginn falsch ist, wird der Code innerhalb der Schleife dennoch mindestens einmal ausgeführt.

Hier ist ein Beispiel für die Verwendung einer do-while-Schleife mit einer booleschen Bedingung:

bool bedingung = true;
do
{
    Console.WriteLine("Die Bedingung ist wahr!");
    bedingung = false;
} while (bedingung);

In diesem Beispiel wird die do-while-Schleife so lange ausgeführt, wie die Bedingung bedingung wahr ist. Der Code innerhalb der Schleife gibt den Text "Die Bedingung ist wahr!" auf der Konsole aus und ändert dann den Wert von bedingung auf false, um sicherzustellen, dass die Bedingung in der nächsten Schleifeniteration falsch ist. Da die Bedingung zu Beginn wahr ist, wird der Code innerhalb der Schleife mindestens einmal ausgeführt.

Kommentare