Bedingungen für Verzweigungs- und Schleifenanweisungen

In diesem Tutorial erfahren Sie, wie Sie Code schreiben, der Variablen untersucht und basierend auf diesen Variablen den Ausführungspfad ändert. Sie schreiben einen C#-Code und sehen dort die Ergebnisse der Kompilierung und Ausführung Ihres Codes. Dieses Tutorial enthält eine Reihe von Lektionen, in denen Verzweigungs- und Schleifenkonstrukte in C# erkundet werden. In diesen Lektionen lernen Sie die Grundlagen der Programmiersprache C# kennen.

Voraussetzungen

Für dieses Tutorial wird vorausgesetzt, dass Sie einen Computer für die lokale Entwicklung eingerichtet haben. Unter Windows, Linux oder macOS können Sie die .NET CLI zum Programmieren, Erstellen und Ausführen von Anwendungen verwenden. Auf dem Mac und unter Windows können Sie Visual Studio 2019 verwenden. Setupanweisungen finden Sie unter Einführung in .NET-Entwicklungstools.

Treffen von Entscheidungen mithilfe der if-Anweisung

Erstellen Sie ein Verzeichnis mit dem Namen branches-tutorial. Legen Sie dieses als das aktuelle Verzeichnis fest, und führen Sie den folgenden Befehl aus:

dotnet new console -n BranchesAndLoops -o .

Wichtig

Die C#-Vorlagen für .NET 6 verwenden Anweisungen der obersten Ebene. Ihre Anwendung passt möglicherweise nicht zum Code in diesem Artikel, wenn Sie bereits ein Upgrade auf die .NET 6-Vorschauversionen durchgeführt haben. Weitere Informationen finden Sie im Artikel Neue C#-Vorlagen generieren Anweisungen auf oberster Ebene.

Das .NET 6 SDK fügt auch eine Reihe impliziter global using-Anweisungen für Projekte hinzu, die die folgenden SDKs verwenden:

  • Microsoft.NET.Sdk
  • Microsoft.NET.Sdk.Web
  • Microsoft.NET.Sdk.Worker

Diese impliziten global using-Anweisungen enthalten die gängigsten Namespaces für den Projekttyp.

Dieser Befehl erstellt im aktuellen Verzeichnis eine neue .NET-Konsolenanwendung. Öffnen Sie Program.cs in Ihrem bevorzugten Editor, und ersetzen Sie den Inhalt durch folgenden Code:

using System;

int a = 5;
int b = 6;
if (a + b > 10)
    Console.WriteLine("The answer is greater than 10.");

Testen Sie diesen Code, indem Sie dotnet run in Ihr Konsolenfenster eingeben. Es sollte folgende Meldung in Ihrer Konsole angezeigt werden: „Die Antwort ist größer als 10.“ Ändern Sie die Deklaration von b so, dass die Summe kleiner als 10 ist:

int b = 3;

Geben Sie erneut dotnet run ein. Da die Antwort kleiner als 10 ist, wird nichts ausgegeben. Die von Ihnen getestete Bedingung ist falsch. Es ist kein Code auszuführen, da Sie lediglich eine der möglichen Verzweigungen für eine if-Anweisung geschrieben haben: die true-Verzweigung.

Tipp

Bei Ihren ersten Schritten mit C# (oder einer anderen Programmiersprache) kann es zu Fehlern kommen, wenn Sie Codes schreiben. Der Compiler findet und meldet die Fehler. Sehen Sie sich die Fehlerausgabe und den Code, der den Fehler erzeugt hat, genau an. Der Compilerfehler kann Ihnen in der Regel helfen, das Problem zu erkennen.

Das erste Beispiel veranschaulicht die Vorteile von if-Anweisungen und Boolean-Typen. Ein boolean-Typ ist eine Variable, die einen der folgenden zwei Werte enthalten kann: true oder false. In C# ist ein besonderer Typ für boolesche Variablen, bool, definiert. Die if-Anweisung überprüft den Wert eines bool-Typs. Wenn der Wert true lautet, wird die nach if folgende Anweisung ausgeführt. Andernfalls wird sie übersprungen. Dieser Vorgang zum Überprüfen von Bedingungen und Ausführen von Anweisungen basierend auf diesen Bedingungen ist wirkungsvoll.

Kombinieren von if- und else-Anweisungen

Um einen anderen Code in den true- und false-Verzweigungen auszuführen, erstellen Sie eine else-Verzweigung, die ausgeführt wird, wenn die Bedingung falsch ist. Versuchen Sie es mit einer else-Verzweigung. Fügen Sie die letzten beiden Zeilen im nachfolgenden Code hinzu (die ersten vier sollten bereits vorhanden sein):

int a = 5;
int b = 3;
if (a + b > 10)
    Console.WriteLine("The answer is greater than 10");
else
    Console.WriteLine("The answer is not greater than 10");

Die Anweisung, die nach dem Schlüsselwort else folgt, wird nur ausgeführt, wenn die zu testende Bedingung false lautet. Wenn Sie if und else mit booleschen Bedingungen kombinieren, müssen Sie sowohl eine true- als auch eine false-Bedingung verarbeiten.

Wichtig

Der Einzug unter den if- und else-Anweisungen dient zur besseren Lesbarkeit. In der Programmiersprache C# werden Einzüge oder Leerräume nicht berücksichtigt. Die Anweisung nach dem Schlüsselwort if bzw. else wird basierend auf der Bedingung ausgeführt. Alle Beispiele in diesem Tutorial folgen der gängigen Vorgehensweise, Zeilen basierend auf der Ablaufsteuerung von Anweisungen mit einem Einzug zu versehen.

Da Einzüge nicht relevant sind, müssen Sie mit { und } angeben, dass Sie mehr als eine Anweisung im Rahmen des bedingt ausgeführten Blocks verwenden möchten. C#-Programmierer verwenden solche geschweifte Klammern in der Regel bei allen if- und else-Anweisungen. Das folgende Beispiel ist identisch mit dem Inhalt, den Sie erstellt haben. Ändern Sie den obigen Code dahingehend, dass er mit dem folgenden Code übereinstimmt:

int a = 5;
int b = 3;
if (a + b > 10)
{
    Console.WriteLine("The answer is greater than 10");
}
else
{
    Console.WriteLine("The answer is not greater than 10");
}

Tipp

Im restlichen Tutorial enthalten alle Codebeispiele geschweifte Klammern gemäß den allgemein gültigen Vorgehensweisen.

Sie können kompliziertere Bedingungen testen. Fügen Sie den folgenden Code unter dem Code hinzu, den Sie bereits geschrieben haben:

int c = 4;
if ((a + b + c > 10) && (a == b))
{
    Console.WriteLine("The answer is greater than 10");
    Console.WriteLine("And the first number is equal to the second");
}
else
{
    Console.WriteLine("The answer is not greater than 10");
    Console.WriteLine("Or the first number is not equal to the second");
}

Die ==-Symboltests für Gleichheit. Die Verwendung von == unterscheidet den Test auf Gleichheit von der Zuweisung, die Sie in a = 5 gesehen haben.

Das Zeichen && steht für „and“. Es bedeutet, dass beide Bedingungen „true“ lauten müssen, damit die Anweisung in der true-Verzweigung ausgeführt wird. Diese Beispiele zeigen außerdem, dass Sie in jeder bedingten Verzweigung mehrere Anweisungen verwenden können, sofern Sie sie mit { und } umschließen. Sie können auch || für „or“ verwenden. Fügen Sie den folgenden Code unter dem Code hinzu, den Sie bereits geschrieben haben:

if ((a + b + c > 10) || (a == b))
{
    Console.WriteLine("The answer is greater than 10");
    Console.WriteLine("Or the first number is equal to the second");
}
else
{
    Console.WriteLine("The answer is not greater than 10");
    Console.WriteLine("And the first number is not equal to the second");
}

Ändern Sie die Werte von a, b und c, und wechseln Sie zwischen && und ||, um sie zu untersuchen. So werden Sie besser verstehen, wie die Operatoren && und || funktionieren.

Sie haben den ersten Schritt abgeschlossen. Bevor Sie mit dem nächsten Abschnitt beginnen, verschieben wir den aktuellen Code in eine separate Methode. Dies erleichtert das Arbeiten mit einem neuen Beispiel. Fügen Sie den vorhandenen Code in eine Methode namens ExploreIf() ein. Rufen Sie sie am Anfang Ihres Programms auf. Nach diesen Änderungen sollte der Code wie folgt aussehen:

using System;

ExploreIf();

void ExploreIf()
{
    int a = 5;
    int b = 3;
    if (a + b > 10)
    {
        Console.WriteLine("The answer is greater than 10");
    }
    else
    {
        Console.WriteLine("The answer is not greater than 10");
    }

    int c = 4;
    if ((a + b + c > 10) && (a > b))
    {
        Console.WriteLine("The answer is greater than 10");
        Console.WriteLine("And the first number is greater than the second");
    }
    else
    {
        Console.WriteLine("The answer is not greater than 10");
        Console.WriteLine("Or the first number is not greater than the second");
    }

    if ((a + b + c > 10) || (a > b))
    {
        Console.WriteLine("The answer is greater than 10");
        Console.WriteLine("Or the first number is greater than the second");
    }
    else
    {
        Console.WriteLine("The answer is not greater than 10");
        Console.WriteLine("And the first number is not greater than the second");
    }
}

Kommentieren Sie den Aufruf von ExploreIf() aus. Dadurch wird die Ausgabe weniger überladen, wenn Sie in diesem Abschnitt arbeiten:

//ExploreIf();

Mit // wird ein Kommentar in C# begonnen. Kommentare sind Texte, die Sie in Ihrem Quellcode beibehalten, jedoch nicht als Code ausführen möchten. Der Compiler generiert keinen ausführbaren Code über die Kommentare.

Wiederholen von Vorgängen durch Schleifen

In diesem Abschnitt verwenden Sie Schleifen, um Anweisungen zu wiederholen. Fügen Sie diesen Code nach dem Aufruf von ExploreIf hinzu:

int counter = 0;
while (counter < 10)
{
    Console.WriteLine($"Hello World! The counter is {counter}");
    counter++;
}

Die while-Anweisung prüft eine Bedingung und führt die Anweisung oder der Anweisungsblock nach while aus. Es wiederholt die Überprüfung der Bedingung und die Ausführung dieser Anweisungen, bis die Bedingung „false“ lautet.

In diesem Beispiel kommt ein weiterer neuer Operator vor. Das ++-Zeichen nach der counter-Variable ist der increment-Operator. Er erhöht den Wert von counter um 1 und speichert diesen Wert in der Variable counter.

Wichtig

Stellen Sie sicher, dass die Schleifenbedingung while zu „false“ wechselt, nachdem Sie den Code ausgeführt haben. Erstellen Sie anderenfalls eine Endlosschleife, durch die das Programm niemals beendet wird. Das wird in diesem Beispiel nicht gezeigt, weil Sie die programmseitige Verwendung von STRG+C oder anderen Mitteln unterbinden müssen.

Die while-Schleife testet die Bedingung, bevor der Code nach while ausgeführt wird. Die do ... while-Schleife führt den Code zuerst aus und überprüft anschließend die Bedingung. Die do while-Schleife wird im folgenden Code gezeigt:

int counter = 0;
do
{
    Console.WriteLine($"Hello World! The counter is {counter}");
    counter++;
} while (counter < 10);

Diese do-Schleife und die vorherige while-Schleife erzeugen die gleiche Ausgabe.

Arbeiten mit der for-Schleife

Die for-Schleife wird üblicherweise in C# verwendet. Testen Sie den folgenden Code:

for (int index = 0; index < 10; index++)
{
    Console.WriteLine($"Hello World! The index is {index}");
}

Der vorherige Code funktioniert auf dieselbe Weise wie die while-Schleife und die do-Schleife, die Sie bereits verwendet haben. Die for-Anweisung besteht aus drei Teilen, die steuern, wie sie ausgeführt wird.

Der erste Teil ist der for-Initialisierer: int index = 0; deklariert, dass index die Schleifenvariable ist, und legt den Anfangswert auf 0 fest.

Der mittlere Teil ist die for-Bedingung: index < 10 deklariert, dass diese for-Schleife ausgeführt wird, solange der Wert des Zählers kleiner als 10 ist.

Der letzte Teil ist der for-Iterator: index++ gibt an, wie die Schleifenvariable geändert wird, nachdem der Block nach der for-Anweisung ausgeführt wurde. Hier gibt dieser an, dass index bei jeder Blockausführung um 1 erhöht werden soll.

Experimentieren Sie selbst. Testen Sie jede der folgenden Variationen:

  • Ändern Sie den Initialisierer, um mit einem anderen Wert zu beginnen.
  • Ändern Sie die Bedingung, um an einem anderen Wert anzuhalten.

Wenn Sie fertig sind, fahren Sie damit fort, mithilfe der erworbenen Kenntnisse selbst Codes zu schreiben.

Eine andere Schleifenanweisung wird in diesem Tutorial nicht behandelt: die foreach-Anweisung. Mit der foreach-Anweisung wird die Anweisung für jedes Element in einer Sequenz von Elementen ausgeführt. Da sie am häufigsten mit Sammlungen verwendet wird, wird sie im nächsten Tutorial behandelt.

Erstellte geschachtelte Schleifen

Eine while-, do- oder for-Schleife kann in einer anderen Schleife geschachtelt werden, um mithilfe der Kombination aus jedem Element in der äußeren Schleife und jedem Element in der inneren Schleife eine Matrix zu erstellen. Durch die Umsetzung dessen können Sie mehrere alphanumerische Paare erstellen, die Zeilen und Spalten darstellen.

Eine for-Schleife kann die Zeilen generieren:

for (int row = 1; row < 11; row++)
{
    Console.WriteLine($"The row is {row}");
}

Eine andere Schleife kann die Spalten generieren:

for (char column = 'a'; column < 'k'; column++)
{
    Console.WriteLine($"The column is {column}");
}

Sie können eine Schleife innerhalb der anderen schachteln, um Paare zu bilden:

for (int row = 1; row < 11; row++)
{
    for (char column = 'a'; column < 'k'; column++)
    {
        Console.WriteLine($"The cell is ({row}, {column})");
    }
}

Sie können erkennen, dass sich die äußere Schleife für jede vollständige Ausführung der inneren Schleife einmal erhöht. Kehren Sie die Schachtelung der Zeilen und Spalten um, und erkennen Sie selbst, was sich ändert. Wenn Sie fertig sind, fügen Sie den Code aus diesem Abschnitt in eine Methode namens ExploreLoops() ein.

Kombinieren von Branches und Schleifen

Nachdem Sie nun die if-Anweisung und die Schleifenkonstrukte in der Programmiersprache C# kennengelernt haben, versuchen Sie, einen C#-Code zu schreiben, der die Summe aller ganzen Zahlen von 1 bis 20 ermittelt, die durch 3 teilbar sind. Im Folgenden einige Tipps:

  • Der %-Operator ermittelt den Restwert einer Divisionsoperation.
  • Die if-Anweisung ermittelt die Bedingung, um festzustellen, ob eine Zahl in der Summe berücksichtigt werden soll.
  • Die for-Schleife ermöglicht es, eine Reihe von Schritten für alle Zahlen von 1 bis 20 zu wiederholen.

Probieren Sie es selbst aus. Prüfen Sie dann, wie Sie abgeschnitten haben. Sie sollten 63 als Antwort erhalten. Sie können eine mögliche Antwort sehen, indem Sie sich den fertig gestellten Code auf GitHub ansehen.

Sie haben das Tutorial „Verzweigungen und Schleifen“ abgeschlossen.

Sie können mit dem Tutorial Arrays und Auflistungen in Ihrer eigenen Entwicklungsumgebung fortfahren.

Weitere Informationen zu diesen Begriffen finden Sie in diesen Artikeln: