Wiederholungen: while und for

Computer sind gut darin, dasselbe sehr oft zu tun, ohne sich zu langweilen. Statt eine Anweisung hundertmal hinzuschreiben, schreiben Sie eine Schleife: einen Block, der wiederholt wird, bis eine Bedingung nicht mehr gilt.

while: solange etwas gilt

// countdown.cs
int zahl = 5;
while (zahl > 0)
{
    Console.WriteLine(zahl);
    zahl = zahl - 1;
}
Console.WriteLine("Start!");

5
4
3
2
1
Start!

Vor jedem Durchlauf prüft while die Bedingung. Ist sie wahr, läuft der Block, danach wird wieder geprüft. Ist sie falsch, geht es hinter dem Block weiter. Im Block wird zahl jedes Mal um eins kleiner, bis die Bedingung zahl > 0 nicht mehr gilt.

Für „um eins kleiner“ und ähnliche Rechnungen gibt es Kurzformen, die Sie oft sehen werden:

Wenn eine Schleife nicht aufhört

Löschen Sie in countdown.cs testweise die Zeile zahl = zahl - 1; und starten Sie das Programm. Jetzt bleibt zahl immer 5, die Bedingung immer wahr, und das Programm schreibt endlos 5 untereinander. Das ist eine Endlosschleife. Kein Grund zur Sorge: Drücken Sie im Terminal Strg+C. Das bricht jedes laufende Programm ab, unter Windows, macOS und Linux. Setzen Sie die Zeile danach wieder ein.

Fragen Sie sich bei jeder Schleife: Was im Block sorgt dafür, dass die Bedingung irgendwann falsch wird?

for: zählen

Sehr oft zählt eine Schleife einfach von einer Zahl bis zu einer anderen. Dafür ist for gemacht:

// einmaleins.cs
for (int i = 1; i <= 10; i++)
{
    Console.WriteLine($"{i} x 7 = {i * 7}");
}

1 x 7 = 7
2 x 7 = 14
3 x 7 = 21
4 x 7 = 28
5 x 7 = 35
6 x 7 = 42
7 x 7 = 49
8 x 7 = 56
9 x 7 = 63
10 x 7 = 70

Die Klammer hinter for hat drei Teile, getrennt durch Semikolons:

1. int i = 1 läuft einmal am Anfang und legt den Zähler an.
2. i <= 10 wird vor jedem Durchlauf geprüft, wie bei while.
3. i++ läuft nach jedem Durchlauf und zählt weiter.

Der Name i ist für Zähler üblich. Sie dürfen ihn aber auch reihe oder nummer nennen.

Werte sammeln

Eine Schleife kann Ergebnisse über alle Durchläufe hinweg sammeln. Dafür legen Sie eine Variable vor der Schleife an und ändern sie in jedem Durchlauf:

// summe.cs
int summe = 0;
for (int i = 1; i <= 100; i++)
{
    summe += i;
}
Console.WriteLine($"Die Summe von 1 bis 100 ist {summe}.");

Die Summe von 1 bis 100 ist 5050.

Läge int summe = 0; im Block, finge die Summe bei jedem Durchlauf wieder bei 0 an, und nach dem Block gäbe es sie gar nicht mehr. Der Compiler würde die letzte Zeile ablehnen. Eine Variable gilt nur in dem Block, in dem sie angelegt wurde.

Eingaben, bis jemand aufhört

Oft weiß ein Programm vorher nicht, wie viele Eingaben kommen. Dann läuft eine Schleife „für immer“, also mit while (true), und wird von innen mit break verlassen, sobald eine bestimmte Eingabe kommt, hier eine leere Zeile:

// zahlen-addieren.cs
int summe = 0;
int anzahl = 0;
Console.WriteLine("Geben Sie ganze Zahlen ein. Eine leere Zeile beendet die Eingabe.");
while (true)
{
    Console.Write("Zahl: ");
    string eingabe = Console.ReadLine() ?? "";
    if (eingabe == "")
    {
        break;
    }

    if (int.TryParse(eingabe, out int zahl))
    {
        summe += zahl;
        anzahl++;
    }
    else
    {
        Console.WriteLine("Das war keine ganze Zahl, ich lasse sie aus.");
    }
}
Console.WriteLine($"{anzahl} Zahlen, Summe {summe}.");

Geben Sie ganze Zahlen ein. Eine leere Zeile beendet die Eingabe.
Zahl: 12
Zahl: 30
Zahl: zwei
Das war keine ganze Zahl, ich lasse sie aus.
Zahl: 8
Zahl:
3 Zahlen, Summe 50.

break beendet die Schleife sofort, das Programm macht hinter ihr weiter. Weil Console.ReadLine() ?? "" am Ende der Eingabe einen leeren Text liefert, endet die Schleife auch dann sauber, wenn gar keine Eingabe mehr kommt.

// zehn-bis-null.cs
for (int i = 10; i >= 0; i -= 2)
{
    Console.WriteLine(i);
}

10
8
6
4
2
0

// zahlenraten.cs
int geheim = 42;
int versuche = 0;
Console.WriteLine("Ich denke mir eine Zahl zwischen 1 und 100.");
while (true)
{
    Console.Write("Ihr Tipp: ");
    string eingabe = Console.ReadLine() ?? "";
    if (eingabe == "")
    {
        Console.WriteLine($"Schade. Die Zahl war {geheim}.");
        break;
    }

    if (!int.TryParse(eingabe, out int tipp))
    {
        Console.WriteLine("Bitte eine ganze Zahl.");
        continue;
    }

    versuche++;
    if (tipp < geheim)
    {
        Console.WriteLine("Zu klein.");
    }
    else if (tipp > geheim)
    {
        Console.WriteLine("Zu groß.");
    }
    else
    {
        Console.WriteLine($"Richtig! Anzahl Ihrer Versuche: {versuche}");
        break;
    }
}

Ich denke mir eine Zahl zwischen 1 und 100.
Ihr Tipp: 50
Zu groß.
Ihr Tipp: 25
Zu klein.
Ihr Tipp: 37
Zu klein.
Ihr Tipp: 43
Zu groß.
Ihr Tipp: 42
Richtig! Anzahl Ihrer Versuche: 5

*
**
***
****
*****

// treppe.cs
for (int zeile = 1; zeile <= 5; zeile++)
{
    for (int stern = 1; stern <= zeile; stern++)
    {
        Console.Write("*");
    }
    Console.WriteLine();
}

Was Sie jetzt können

• Sie wiederholen Anweisungen mit while, solange eine Bedingung gilt.
• Sie zählen mit for und wählen Anfang, Ende und Schrittweite selbst.
• Sie verlassen eine Schleife mit break, überspringen einen Durchlauf mit continue und beenden ein hängendes Programm mit Strg+C.
• Sie sammeln Werte in einer Variablen, die vor der Schleife angelegt ist.
• Sie schachteln Schleifen ineinander.

Weiterlesen

• Branches and loops: Schleifen in Microsofts Tutorial-Reihe, mit do-Schleife und verschachtelten Schleifen.
• Iterate through a code block using for statement in C#: ein Modul mit Übungen zu for.
• Add looping logic to your code using the do-while and while statements in C#: ein Modul zu while und do.