Ablaufsteuerung in C#
Zu Teil 2: Erste Schritte in C#
Teil 3: Ablaufsteuerung in C#
Zu Teil 4: In C# integrierte Datentypen
Im vorherigen Kapitel haben wir erste, sehr rudimentäre Beispiele für C#-Programme gesehen. Hierbei bestand der Programmablauf immer genau aus der vorgegebenen Abfolge von Instruktionen, die der Reihe nach abgearbeitet werden. Um komplexe Programme erstellen zu können, benötigen wir jedoch mehr Möglichkeiten, den Programmablauf zu strukturieren. Wir wollen z.B. bestimmte Codeabschnitte unter Umständen überspringen und wir wollen die Möglichkeit haben, Codeabschnitte mehrmals auszuführen.
Die Werkzeuge, die dies ermöglichen, werden wir in diesem Kapitel kennen lernen.
Bedingungen
Bedingungen ermöglichen es uns, bestimmte Codeabschnitte unter Umständen zu überspringen. Wir können damit den Programmablauf verzweigen, d.h. bei unterschiedlichen Vorbedingungen kann das Programm jeweils einen anderen Ablauf nehmen.
Stellen Sie sich zum Beispiel ein Programm vor, das den Zugriff auf nicht jugendfreie Videos verwaltet. Ein solches Programm wird zunächst das Alter des Benutzers bestimmen. Je nach Alter wird das Programm dann entweder die Videos bereit stellen oder aber einen Hinweis darauf geben, dass die Videos für einen Nutzer mit dem angegebenen Alter nicht geeignet sind. Je nach Vorbedingung kann das Programm also sehr unterschiedliche Abläufe nehmen.
In C# gibt es das sogenannte if-else-Konstrukt, um eine solche Ablaufsteuerung zu ermöglichen. Das if-else-Konstrukt wird nach der folgenden allgemeinen Syntax realisiert:
if ()
{
;
;
...
}
else
{
;
;
...
}
Wir finden hier also zwei Codeblöcke vor, die jeweils mit einem Paar von geschweiften Klammern abgegrenzt werden. Tatsächlich können innerhalb der Codeblöcke wiederum beliebig viele Anweisungen geschachtelt werden.
Zu Beginn findet sich eine „Bedingung“. Was eine Bedingung genau ist, werden wir gleich noch sehen. Zunächst jedoch zum konkreten Ablauf eines solches Konstruktes: zu Beginn wird also die Bedingung geprüft, die sich nach dem einleitenden if innerhalb der runden Klammern befindet. Ist die Bedingung erfüllt, wird danach der gesamte erste Codeblock ausgeführt (also die Anweisungen 1, 2, …). Der Codeblock, der hinter dem else-Teil folgt, wird dagegen in diesem Fall übersprungen. Ist dagegen die einleitende Bedingung nicht erfüllt, so wird der erste Codeblock übersprungen und ausschließlich der zweite Codeblock (also die Anweisungen 3, 4, …) ausgeführt.
Der else-Teil ist übrigens optional. Eine if-Anweisung benötigt nicht zwingend einen else-Teil. Sofern keine else-Klausel vorhanden ist wird bei Nichterfüllung der Bedingung einfach das komplette Konstrukt übersprungen und der Ablauf des Programmes wird mit der ersten Anweisung nach dem kompletten if-Konstrukt fortgesetzt.
Möglichkeiten, Bedingungen zu formulieren gibt es in C# sehr viele. Oft werden dabei die sogenannten Vergleichsoperatoren eingesetzt. Diese sind <, <=, ==, !=, >= und < (kleiner, kleiner gleich, gleich, ungleich, größer gleich und größer). Mit Hilfe dieser Operatoren können so Bedingungen formuliert werden, die auf gewöhnlichen Zahlen operieren.
Beispiele für Bedingungen wären z.B.
5 >= 8summand2 < 93 * summand1 != summand2 / 7
Es wird geprüft, ob 5 größer oder gleich 8 ist. Da dies nicht der Fall ist, ist die Bedingung nicht erfüllt.
Es wird geprüft, ob eine Variable summand2 kleiner als 9 ist. Ob dies der Fall ist, hängt natürlich vom konkreten Wert, der in der Variablen summand2 gespeichert ist, ab. Je nach Belegung dieser Variablen kann das Programm also unterschiedliche Abläufe nehmen.
Es wird geprüft, ob das Produkt aus summand1 und 3 ungleich dem Ergebnis der Division von summand2 durch 7 ist. Ob dies der Fall ist, hängt abermals von den Werten, die in den Variablen gespeichert sind, ab. Sie sehen hierbei, dass Sie auch andere arithmetische Operatoren sehr intuitiv nutzen können. Der Stern wird zur Berechnung einer Multiplikation genutzt, der einfache Slash zur Durchführung einer Division.
Unser C#-Tutorial
Lesen Sie hier die ersten 4 Kapitel kostenlos!
Um zu unserem einleitenden Beispiel zurück zu kommen: die Realisierung einer Altersprüfung könnte (natürlich sehr stark vereinfacht) folgendermaßen aussehen:
int alter = 17;
if (alter >= 18)
{
Console.WriteLine("Sie erhalten Zugriff auf "+
"unsere Video-Bibliothek");
...
}
else
{
Console.WriteLine("Leider koennen wir Ihnen unseren "+
"Service nicht anbieten");
}
Zunächst wird also das Alter geprüft und in einer Variable alter gespeichert. In unserem Fall haben wir das vereinfacht und geben einfach ein Alter direkt im Quellcode an. In der Realität würde man an dieser Stelle eine tatsächliche Prüfung vornehmen, z.B. durch Prüfung der Ausweisnummer.
Wenn das Alter 18 oder mehr beträgt, geben wir dem Benutzer Zugriff auf die Video-Bibliothek (im Beispiel wird nicht tatsächlich eine Video-Bibliothek bereit gestellt, sondern nur ein entsprechender Hinweis auf der Konsole ausgegeben). Hat der Nutzer dagegen nicht das Mindestalter von 18 Jahren, wird ihm der Zugriff verweigert und er erhält eine entsprechende Mitteilung.
Programmieren mit C# - Einige unserer Empfehlungen
Schleifen
Mit Schleifen können wir den Ablauf eines Programms so beeinflussen, dass ein Codeblock mehrfach ausgeführt wird. Auch hierbei kann ein Programm wieder sehr unterschiedliche Abläufe nehmen: in einem Fall wird ein Codeblock möglicherweise gar nicht ausgeführt, in einem anderen Fall zwei mal und in einem weiteren Fall fünf mal.
Wie oft ein Codeblock einer Schleife ausgeführt wird, wird abermals mit einer Bedingung festgelegt. Anders als bei dem if-else-Konstrukt, das wir aus dem vorherigen Abschnitt bereits kennen, wird die Bedingung jedoch nicht nur einmal geprüft, sondern mehrfach. Die Idee dahinter ist relativ simpel: ein Codeblock wird so lange ausgeführt, wie eine Bedingung erfüllt ist. Sobald die Bedingung nicht mehr erfüllt ist, wird der Codeblock kein weiteres Mal durchgeführt.
while-Schleife
Es gibt in C# verschiedene Arten von Schleifen, wir werden hier nur die while-Schleife und die for-Schleife behandeln. Wir beginnen mit der einfachsten Schleife, der while-Schleife. Bei dieser wird einfach nur eine Bedingung geprüft und der Schleifenrumpf (d.h. der Codeblock, der der Bedingung folgt) so lange ausgeführt, wie die Bedingung erfüllt ist.
Die allgemeine Syntax der while-Schleife ist wie folgt:
while ()
{
;
;
...
}
Der Ablauf einer solchen Schleife ist also wie folgt: zunächst wird die Bedingung geprüft. Ist die Bedingung erfüllt, wird der nachfolgende Codeblock ausgeführt. Danach wird die Bedingung erneut geprüft. Ist sie immer noch erfüllt, wird auch der Codeblock ein weiteres Mal ausgeführt. Dies geschieht so lange, bis die Bedingung nicht mehr erfüllt ist. Danach terminiert die Schleife (d.h. der Programmablauf wird mit der ersten Zeile nach dem kompletten Schleifen-Konstrukt fortgesetzt).
Eine relativ oft vorkommende Anwendung einer Schleife ist es, wenn man einen Codeblock für eine genau definierte Anzahl von Durchgängen ausführen will. In diesem Fall legt man eine Zählvariable an, die mitzählt, wie oft der Schleifenrumpf schon durchlaufen wurde. In der Bedingung wird geprüft, ob die Zählvariable den festgelegten Schwellwert bereits erreicht hat.
Ein Programm, das 10 mal den Text Hallo Welt auf der Konsole ausgibt, lässt sich also folgendermaßen mit Hilfe einer while-Schleife realisieren:
int zaehler = 0;
while (zaehler < 10)
{
Console.WriteLine("Hallo Welt");
zaehler = zaehler + 1;
}
Die Zählvariable wird also zunächst mit dem Wert 0 initialisiert. Die Bedingung der Schleife prüft, ob die Zählvariable noch kleiner als 10 ist. So lange das der Fall ist, wird der Schleifenrumpf ausgeführt, sobald die Zählvariable 10 erreicht, wird die Ausführung der Schleife jedoch eingestellt.
Im Rumpf wird dann zunächst die Ausgabe auf der Konsole getätigt und danach die Zählvariable um 1 vergrößert. Der Rumpf wird damit genau 10 mal ausgeführt, da die Zählvariable beim zehten Durchlauf den Wert 10 erreicht und bei der nachfolgenden Prüfung die Bedingung nicht mehr erfüllt ist.
for-Schleife
Der zuvor beschriebene Fall mit einer dedizierten Zählvariable kommt beim Programmieren recht häufig vor. Die for-Schleife ist der while-Schleife relativ ähnlich, allerdings kann dort die Zählvariable direkt in die Schleife integriert werden. Daher werden in den Fällen, in denen es eine Zählvariable gibt, meistens for-Schleifen benutzt.
Die allgemeine Syntax der for-Schleife ist die folgende:
for (; ; )
{
;
;
...
}
Im "Header" der for-Schleife findet sich nun nicht nur die Bedingung, sondern darüber hinaus noch ein sogenannter Initialisierungsteil und ein Inkrement-Teil. Der Initialisierungsteil wird dabei genau einmal ganz zu Beginn durchgeführt. Diesen verwendet man z.B. dafür, die Zählvariable zu erstellen und zu initialisieren. Der Inkrementteil wird automatisch nach jedem Durchlauf des Schleifenrumpfes ausgeführt. Man kann diesen daher dazu verwenden, die Zählvariable entsprechend anzupassen. Das Vergrößern einer Variable um den Wert 1 nennt man auch Inkrementieren, daher nennen wir diesen Teil des Schleifen-Headers den Inkrement-Teil: weil hier in der Regel die Zählvariable inkrementiert wird.
Das gleiche Beispiel, das wir zuvor für die while-Schleife gesehen haben, lässt sich also wie folgt über eine for-Schleife realisieren:
for (int zaehler = 0; zaehler < 10; zaehler = zaehler + 1)
{
Console.WriteLine("Hallo Welt");
}
Der Vorteil liegt darin, dass wir hier die Logik der Zählvariable nicht mit unserem eigentlichen Code vermischen müssen, sondern den Code für die Zählvariable schön separat komplett in den Header der Schleife verlagern können.
Nun noch einige Hinweise zu Schleifen: zum einen hat es sich eingebürgert, für Zählvariablen sehr kurze und einfache Namen wie i oder j zu verwenden. Zuvor hatten wir gesagt, dass generische Namen für Variablen zu vermeiden sind, dass man stattdessen Namen wählen sollte, die den Zweck einer Variable erkennen lassen. Dies ist eine Ausnahme hierfür, die Verwendung von Namen wie i oder j für Zählvariablen ist so gebräuchlich, dass man von dem Namen direkt ableiten kann, dass es sich um Zählvariablen handelt.
Das Inkrementieren von Variablen ist ebenfalls eine so häufige Tätigkeit, dass in die Programmiersprache C# (übrigens ebenso wie in viele andere Programmiersprachen) eine Abkürzung hierfür eingebaut ist. Um eine Variable i um 1 zu vergrößern, schreibt man deshalb kurz
i++
statt i = i + 1
Analog funktioniert das auch mit -- um eine Variable um 1 zu verkleinern (man nennt das Dekrementieren).
Im übrigen können wir die Zählvariable auch innerhalb des Schleifenrumpfes verwenden. Man kann dies z.B. nutzen, um Summen zu berechnen. Eine Schleife, die die Summe der Zahlen von 1 bis 10 (also 1 + 2 + 3 + ... + 9 + 10) berechnet wird folgendermaßen realisiert:
int summe = 0;
for (int i = 1; i <= 10; i++)
{
summe = summe + i;
}
Console.WriteLine("Die Summe lautet " + summe);
Hier legen wir also zunächst eine Summenvariable an, in der wir die Summe speichern wollen. Nun erzeugen wir eine for-Schleife. Wir verwenden eine Zählvariable i, diese initialisieren wir mit dem Wert 1. In der Bedingung wird geprüft, ob die Zählvariable kleiner oder gleich 10 ist. Im Inkrement-Teil der Schleife wird die Zählvariable inkrementiert. Im Rumpf der Schleife addieren wir lediglich den aktuellen Wert der Zählvariable zu unserer Summenvariable.
Wir wollen den konkreten Ablauf der Schleife jetzt einmal im Detail durchgehen.
- Zu Beginn wird die Zählvariable
imit 1 initialisiert. Die nachfolgende Prüfung der Bedingungi <= 10ist erfolgreich, daigleich 1 ist. Daher wird der Rumpf ausgeführt. - Es wird zunächst die Summe berechnet aus
summe(die Variable hat den Wert 0) undi(1). Das Ergebnis (1) dieser Addition wird nun in der Variablesummegespeichert. - Damit ist der erste Durchlauf der Schleife bereits beendet und der Inkrement-Teil wird ausgeführt, d.h. die Zählvariable
iwird um 1 vergrößert und hat nun den Wert 2. - Die Prüfung der Bedingung ist weiterhin erfolgreich, da
igleich 2 ist und damit immer noch kleiner oder gleich 10. Damit wird der Schleifenrumpf ein weiteres Mal ausgeführt. - Im Schleifenrumpf wird nun wieder die Summe berechnet aus der Variable
summe(1) und der Variablei(2). Das Ergebnis 3 wird demnach in der Variablesummegespeichert. - Abermals wird die Zählvariable
iinkrementiert und hat nun den Wert 3. - Das geht nun so weiter, bis die Zählvariable
iden Wert 10 hat. In diesem Fall wird der Rumpf noch ein letztes Mal ausgeführt. Bei der nachfolgenden Inkrementierung der Zählvariableierhält diese nun aber den Wert 11. Damit schlägt die Prüfung der Bedingung fehl und die Schleife terminiert letztendlich.
Über diesen Kurs
Dieses Tutorial richtet sich an Einsteiger, die C# programmieren lernen wollen. Die ersten 4 Kapitel des Tutorials, in denen die Grundlagen erklärt werden, können Sie bereits auf der Webseite lesen.
Die Einführung für Anfänger umfasst unverzichtbare Elemente der Programmiersprache wie Bedingungen und Schleifen, Variablen und Datentypen.
Die komplette Version des Tutorials kann in Buchform erworben werden. Sie steht sowohl als gedrucktes Buch als auch als eBook zur Verfügung. In diesem erweiterten C#-Tutorial für Einsteiger, die Programmieren lernen wollen, werden viele weitere Themen wie Operatoren, Ausdrücke, Klassen und Vererbung anfängergerecht präsentiert. Zudem werden auch fortgeschrittene Themen wie die Erstellung von grafischen Benutzeroberflächen mit der Windows Presentation Foundation (WPF) und Netzwerkprogrammierung angeschnitten. Des weiteren enthält enthält das Komplett-Tutorial umfangreiche Begleitmaterialien wie eine Download-Möglichkeit des Beispielcodes, Übungen und Lösungsvorschläge für die Übungen.
Ab 6 Euro
Zufriedenheitsgarantie: Sie können sich den Kaufpreis über Amazon erstatten lassen, wenn Sie mit dem Tutorial nicht zufrieden sind.
Zu Amazon
Zu Teil 2: Erste Schritte in C#
Teil 3: Ablaufsteuerung in C#
Zu Teil 4: In C# integrierte Datentypen
Eine ausführliche Liste unserer Buchempfehlungen für C# finden Sie hier.
Unsere Buchempfehlungen
Wir haben auch eine Empfehlung für einen C#-Fernkurs parat.