Inhaltsverzeichnis

1. Was sind Klassen?

Wie bereits im vorherigen Beitrag beschrieben: Klassen sind Baupläne für Objekte.

In einer Klasse definieren wir alle Eigenschaften, Methoden und anderen Member, die ein Objekt der Klasse haben soll. Member sind all die Dinge, die in einer Klasse definiert werden, die ein Objekt dann später besitzt. Dazu zählen Eigenschaften, Methoden und andere Dinge, die du noch kennenlernen wirst.

Sobald eine Klasse definiert ist, kann man davon Objekte erzeugen. Und zwar beliebig viele. An dieser Stelle möchte ich dir ein einfaches Beispiel für eine Klasse zeigen, damit du siehst, wie man diese definieren kann:

Inhaltsverzeichnis

1. Was bedeutet objektorientierte Programmierung?

Die Objektorientierung ist ein Programmierparadigma. Doch so schwierig wie dieser Begriff klingt, ist es tatsächlich gar nicht. Anders gesagt ist ein Programmierparadigma ein Programmierstil. Ich sage auch gerne „Denkweise“ dazu, mit der man mit einer bestimmten Programmiersprache arbeitet. Schließlich ist ein Programmierstil im Grunde genommen eine bestimmte Art und Weise beim Programmieren zu denken.

Die OOP (Objektorientierte Programmierung) ist dem menschlichen Denken sehr ähnlich. Das hat einen ganz bestimmten Grund: Alles in der OOP wird durch sogenannte Objekte beschrieben. Diese Denkweise ist dem menschlichen Denken deshalb so ähnlich, weil wir in der echten Welt auch die verschiedenen Dinge, die um uns herum existieren, als Objekte wahrnehmen.

Wenn wir beispielsweise durch ein Zimmer laufen, dann laufen wir durch einen physischen Raum, in dem verschiedene Objekte existieren. Auf meinem Schreibtisch sehe ich zum Beispiel gerade eine Kaffeetasse. Dieser Kaffeetasse kann ich verschiedene Eigenschaften zuordnen, wie etwa eine Farbe. Dazu aber gleich noch mehr.

In der objektorientierten Programmierung ist es auch so, dass alle Dinge, die in unserem Programm existieren, solche Objekte sind. Wenn wir also beispielsweise ein Videospiel programmieren, in dem es ein Kamel in einem Wüstenlevel gibt, dann ist dieses Kamel ein Kamelobjekt.

Wenn wir eine Verwaltungssoftware für unsere Mitarbeiter unserer Firma schreiben, können wir jeden einzelnen Mitarbeiter in dieser Software als ein Personenobjekt darstellen.

Wenn wir eine Immobiliensoftware schreiben, dann können wir jedes Haus, das wir in unserer Software verwalten, als ein Hausobjekt darstellen.

Und das ist im Grunde die objektorientierte Programmierung in C#. Es geht dabei also um diese Objekte. Wenn wir Dinge in unserem Programm erstellen, dann erstellen wir diese als Objekte. Was man genau unter diesen Objekten versteht, werde ich dir jetzt im weiteren Verlauf dieses Artikels erklären.

Inhaltsverzeichnis

1. Was ist eine C# foreach Schleife?

Foreach Schleifen nutzt man in C# zum Durchlaufen von Datenstrukturen, wie etwa Arrays. Wenn wir also beispielsweise ein großes Array erstellt haben, dessen Werte wir alle auf der Konsole ausgeben lassen möchten, bietet sich eine foreach Schleife sehr gut dafür an.

Dabei besitzt sie im Unterschied zur for Schleife keine Zählervariable. Die C# foreach Schleife hat lediglich eine Variable, die auf das aktuell zu durchlaufende Objekt referenziert.

Diesen Unterschied zu verstehen ist sehr wichtig. Bei einer gewöhnlichen for Schleife hat man bekanntermaßen die Zählervariable. Diese beinhaltet immer den Index des Arrays, den wir durchlaufen. Bei der foreach Schleife haben wir diesen Index hingegen nicht. Statt der Zählervariable haben wir lediglich eine einzige Variable, in welcher sich immer das aktuell durchlaufene Objekt befindet.

Das bedeutet: Möchten wir nochmals Zugriff auf das in der Iteration zuvor durchlaufene Objekt, ist das bei einer foreach Schleife nicht möglich. Das werden wir uns aber gleich noch genauer ansehen.

Werfen wir nun mal einen Blick auf das folgende Beispiel:

Im Beispiel habe ich zunächst ein String Array erstellt. Dabei handelt es sich genauer gesagt um ein eindimensionales Array vom Typ String namens „namen“, in welchem sich die vier Namen Claudia, Hans, Aline und Giuseppe befinden.

Darunter habe ich eine foreach Schleife gesetzt, in welcher ich jeden Einzelnen dieser Namen durchlaufe und diese dann jeweils in der Konsole ausgebe. Doch wie funktioniert die foreach Schleife und wie ist sie aufgebaut?

2. Aufbau der C# foreach Schleife

Man beginnt die foreach Schleife mit dem Schlüsselwort foreach. Anschließend folgt ein Klammerpaar. In diesem Klammerpaar deklariert man zunächst eine Variable, die immer das aktuell durchlaufene Objekt beinhalten soll. Wir durchlaufen hierbei jeden einzelnen Namen im Array namen. Und genau das schreiben wir auch so aus. Es folgt also das Schlüsselwort „in“. In welchem Array bzw. welcher Datenstruktur passiert das? In der, die sich in der Variable namen befindet. Das ist schließlich die Variable, die dieses String Array beinhaltet.

Wir weisen hier also das Programm an, jeden String name im Array namen zu durchlaufen. Daraufhin folgt darunter beispielhaft zwischen den geschweiften Klammern Console.WriteLine(name). In name befindet sich immer der aktuell durchlaufene Name. Wenn wir das Beispiel nun ausführen, sehen wir in der Konsole all diese vier Namen aus dem Array ausgegeben:

Was den Aufbau betrifft, ist das im Grunde alles, was man zur C# foreach Schleife sagen kann. Es gibt allerdings noch eine ganz wichtige Besonderheit, die ich dir gleich noch an einem praktischen Beispiel zeigen werde.

Sehen wir uns hierzu direkt ein weiteres Beispiel an.

3. Die C# foreach Schleife in der Praxis

Für unser Praxisbeispiel erstellen wir uns jetzt erst einmal eine Datenstruktur, die wir durchlaufen können. Hierfür wählen wir ein eindimensionales Array vom Typ Integer, welches wir numbers nennen. In das Array schreiben wir die Zahlen 10, 20, 25 und 40 und schließen das Ganze mit einem Semikolon ab:

Damit haben wir also das Array numbers erstellt. Jetzt versuchen wir, jede einzelne dieser Zahlen mit einer foreach Schleife zu durchlaufen.

Dafür schreiben wir wieder das Schlüsselwort foreach, gefolgt von einem Klammerpaar. In diesem Klammerpaar deklarieren wir jetzt eine Variable, in der sich immer das aktuell durchlaufene Objekt befinden soll.

Da es sich um Integer handelt, die wir in diesem Array durchlaufen, befindet sich das aktuell durchlaufene Objekt immer in der Integer Variable, die wir hier nun number nennen. Die Zahlen durchlaufen wir jetzt also im Array numbers, das wir oben erstellt haben:

Damit haben wir also auch eine foreach Schleife gebaut, die jede Zahl (number) in numbers durchläuft. Darunter können wir jetzt beispielsweise ein Console.WriteLine setzen und jede number somit auf der Konsole ausgeben:

Beim Starten des Programms sehen wir, dass es die Zahlen 10, 20, 25 und 40 in der Konsole ausgibt:

Wie ich vorhin erwähnt habe, möchte ich noch auf eine Besonderheit eingehen, die man unbedingt verstehen sollte.

Wenn man in C# foreach Schleifen nutzt, um bspw. die verschiedenen Objekte in einem Array zu durchlaufen, muss man verstehen, dass man die Variable, in der sich das aktuell durchlaufene Objekt befindet, nicht verändern kann. In unserem Beispiel ist das die Variable number.

Ich könnte also number nicht auf einen anderen Wert setzen, wie zum Beispiel 200:

Wie wir sehen, erhalten wir auch direkt einen Fehler, der folgendermaßen lautet:

Übersetzt bedeutet diese Fehlermeldung: „‘number‘ ist foreach Iterationsvariable. Eine Zuweisung ist daher nicht möglich.“

Es ist also sehr wichtig zu verstehen, dass man für den Versuch, dem Index einen anderen Wert zuzuweisen, den man aktuell durchläuft, eine normale for Schleife verwenden muss. Schließlich kann man in der C# foreach Schleife den Wert der Iterationsvariable nicht verändern.

Inhaltsverzeichnis

1. Was ist eine C# for Schleife?

1.1. Aufbau einer for Schleife

For Schleifen setzt man vor allem dann ein, wenn man bereits weiß, wie oft eine Schleife ausgeführt werden soll. Sie besteht aus einer Zählervariable, einer Bedingung zum Weitermachen und einer mathematischen Operation an der Zählervariable, die das Programm nach jedem Durchlauf ausführt.

Mit for Schleifen kann man beispielsweise Arrays oder bestimmte Codeblöcke mehrmals durchlaufen. Da sie ziemlich nützlich sind, finden sie in der Praxis häufig ihren Einsatz.

Doch wie sieht eine C# for Schleife eigentlich aus? Um diese Frage zu beantworten, sehen wir uns die einzelnen Komponenten einmal auf der folgenden Abbildung an:

Wie du sehen kannst, habe ich hier eine einfache for Schleife als Beispiel gebildet.

Man beginnt eine For Schleife immer mit dem Schlüsselwort for, gefolgt von einem Klammerpaar. In diesem Klammerpaar initialisiert man zuerst die Zählervariable. Das heißt, wir haben einen Integer als Zählervariable, den wir bei for Schleifen in der Regel als i bezeichnen und weisen diesem einen Wert zu. Im Falle unseres Beispiels den Wert 0.

Auf diese Zählervariable kann man auch innerhalb der Schleife zugreifen. Das ist ziemlich nützlich, da man so immer weiß, im wievielten Durchlauf man sich aktuell befindet. Dieser Wert steckt nämlich immer in der Zählervariable i.

Nach der Initialisierung der Zählervariable folgen ein Semikolon und daraufhin die Bedingung zum Weitermachen. Hier legen wir nun fest, dass die for Schleife so lange laufen soll wie i einen kleineren Wert beinhaltet als 10. Das heißt: Solange i kleiner als 10 ist, führt das Programm die for Schleife aus und wiederholt diese weiterhin.

Nach der Bedingung folgt ein weiteres Semikolon und anschließend die mathematische Operation, die das Programm nach jedem Durchlauf der Schleife durchführt. Mit i++ weisen wir das Programm an, den Wert von i um eins zu erhöhen. i++ bedeutet so viel wie i += 1. Das doppelte +-Zeichen ist eine verkürzte Form davon.

1.2. Grundlegender Ablauf einer for Schleife

Was passiert nun also, wenn wir diese C# for Schleife ausführen lassen? Zuerst setzt das Programm i auf 0. Dann prüft es, ob i kleiner als 10 ist. Da das in unserem Beispiel der Fall ist, führt das Programm den Codeblock der for Schleife aus. In diesem habe ich Console.WriteLine(i) geschrieben, wodurch also 0 in der Konsole ausgegeben wird.

Sobald der Codeblock durchlaufen ist, springt das Programm wieder zu der mathematischen Operation und erhöht i um 1. Danach springt es wieder in die Bedingung und prüft, ob i, welches jetzt den Wert 1 beinhaltet, immer noch kleiner als 10 ist. Weil das tatsächlich immer noch der Fall ist, führt das Programm den Codeblock nochmals aus und gibt in der Konsole den Wert 1 aus.

Nach diesem Prozess kehrt das Programm wieder nach oben (in den Kopf der for Schleife) zurück und erhöht i um eins. Die Variable i enthält nun also bereits den Wert 2. Nun prüft es erneut, ob die Variable i mit dem Wert 2 immer noch kleiner als 10 ist. Das ist immer noch der Fall, weshalb auch der Codeblock erneut ausgeführt wird.

Sobald i beim Wert 9 angekommen ist, gibt das Programm auch diesen Wert noch aus und erhöht ihn im Anschluss zum letzten Mal um 1. Jetzt befindet sich der Wert 10 in der Variable i und das Programm prüft, ob 10 kleiner als 10 ist. Da das nicht der Fall ist, führt es die for Schleife auch nicht mehr weiter aus.

So funktioniert im Grunde die C# for Schleife. Wenn man das Prinzip einmal verstanden hat, ist das also ziemlich einfach. Damit du das Ganze auch wirklich nachvollziehen kannst, schauen wir uns die C# for Schleife nun in der Praxis an. An dieser Stelle empfehle ich dir, selbst Visual Studio zu öffnen und den Code zum besseren Verständnis parallel mitzuschreiben.

2. C# for Schleife in der Praxis

Wir beginnen unser Praxisbeispiel mit einer einfachen for Schleife. Wie leitet man eine for Schleife in C# ein? Man schreibt zunächst das Schlüsselwort for. Anschließend bildet man ein Klammerpaar und initialisiert darin erst mal eine Zählervariable.

Das ist in der Regel ein Integer namens i. Wir schreiben also int i, initialisieren i direkt mit dem Wert 0 und setzen ein Semikolon:

Statt der 0 könnten wir natürlich auch einen beliebigen anderen Wert wählen. Zum Beispiel wäre es ebenso möglich, bei 10 oder -10 anzufangen.

Nach der Initialisierung der Zählervariable folgt die Bedingung zum Weitermachen. Es verhält sich also ähnlich wie in einer while Schleife. Wir müssen nun mit dieser Zählervariable zusammen eine Bedingung bilden. Diese könnte beispielsweise so aussehen, dass das Programm die for Schleife so lange ausführen soll wie i einen Wert hat, der kleiner oder gleich dem Wert 100 ist. Dann setzen wir ein weiteres Semikolon:

Dahinter können wir jetzt zum Beispiel i++ schreiben. Wie bereits oben im Theoriebeispiel erklärt: i++ ist dasselbe wie i += 1. Mit i++ erhöhen wir also im Grunde i um eins:

An dieser Stelle kommt auch schon der Codeblock. Wir haben nun also eine Schleife, die das Programm 101-mal durchläuft. 101-mal, denn wir starten bei 0 und die 100 wird auch noch durchlaufen.

Jetzt können wir zum Beispiel Console.WriteLine schreiben und i bei jedem Durchlauf ausgeben lassen:

Wenn wir das Programm nun einmal starten, sehen wir, dass in der Konsole die Zahlen 0 bis 100 ausgegeben werden.

Das Ganze ist also ziemlich einfach, wie man sieht.

Lassen wir bei der Bedingung das = weg und schreiben stattdessen i < 100, führt das Programm den Codeblock nur 100-mal aus:

Wenn wir diesen Code ausführen, so sehen wir, dass nun die Werte von 0 bis 99 ausgegeben werden.

Das ist also die einfachste Art und Weise, die C# for Schleife zu verwenden.

3. Mit der for Schleife Arrays durchlaufen

Zu Beginn habe ich erwähnt, dass man mit for Schleifen auch Arrays durchlaufen kann. Das ist tatsächlich eine ziemlich interessante Eigenschaft von for Schleifen, die wir uns jetzt einmal ansehen werden. Man verwendet dazu die Zählerschleife.

Um das Ganze umzusetzen, erstellen wir zunächst ein String Array. Dieses nennen wir names und darin speichern wir die nachfolgenden Namen:

Jetzt können wir mithilfe einer for Schleife all diese Namen in der Konsole ausgeben lassen.

Dafür leiten wir die for Schleife wie gewohnt mit dem Schlüsselwort for und dem darauffolgenden Klammerpaar ein. In das Klammerpaar schreiben wir wieder dieselben Komponenten wie im vorherigen Beispiel auch. Wir beginnen also mit der Zählervariable i, die wir erst mal auf 0 setzen:

Beim Durchlaufen eines Arrays ist es sehr wichtig, dass wir den Wert der Variable zu Beginn auf 0 setzen, da der erste Index eines Arrays in C# immer der nullte Index ist. Wir starten also bei Index 0.

Die Bedingung ist, dass wir das Array so lange durchlaufen, wie i kleiner ist als die Gesamtmenge an Elementen in diesem Array. Doch wie finden wir die Gesamtmenge heraus? Auf der einen Seite können wir zählen, wodurch wir auf fünf Elemente kommen.

Wenn aber dieses Array erst zur Laufzeit entsteht und Werte hineingeschrieben werden, kann dessen Größe variieren. Aus diesem Grund müssen wir die Größe des Arrays auf eine andere Art und Weise herausfinden.

Aber wie finden wir diese heraus? Ganz einfach, indem wir den Namen des Arrays schreiben, einen Punkt setzen und anschließend „Length“ hinzufügen:

Length ist eine Eigenschaft der Array Klasse, welche immer die Anzahl an Elementen im Array beinhaltet.

Wir können diese also nutzen, um die Anzahl der Elemente unseres Arrays herauszufinden. So können wir festlegen, dass das Programm das Array so lange durchlaufen soll wie i kleiner ist als die Anzahl an Elementen.

Anschließend schreiben wir noch i++, um i nach jedem Durchlauf um eins zu erhöhen:

Nun kommt der Schleifenkörper, in welchem wir immer i als Index vom Array names ausgeben lassen:

Der Wert i verändert sich mit jedem Durchlauf. Wir beginnen bei 0 und gehen bis zum letzten Element des Arrays. Die Schleife läuft also so lange, wie i kleiner ist als die Anzahl an Elementen. Somit gibt das Programm jeden Namen darin aus:

Wie wir sehen, stehen nun alle Namen in der Konsole. Dafür sind C# for Schleifen also auch sehr nützlich!

Falls du die C# for Schleife noch immer etwas verwirrend findest, empfehle ich dir für ein besseres Verständnis, in der Praxis noch selbst damit zu üben.

Inhaltsverzeichnis

1. Was sind C# 2D Arrays?

Während 1D Arrays wie eine Liste von Werten strukturiert sind, kann man sich in C# 2D Arrays wie eine Tabelle oder wie ein Raster aus Werten vorstellen. Mit zwei Dimensionen, also mit Zeilen und Spalten.

Ein 2D-Array sieht in C#-Code folgendermaßen aus:

Das hier ist ein einfaches String-Array mit zwei Dimensionen. Genannt habe ich dieses einfach mal „products“. Du siehst, man erstellt das Ganze auf einem sehr ähnlichen Weg wie ein 1D-Array, nur dass man beim Erstellen eines C# 2D Arrays in das eckige Klammerpaar noch ein Komma setzt.

Bei der Erstellung muss man nämlich Größen für zwei verschiedene Dimensionen angeben. Einmal geben wir die Anzahl der Spalten pro Zeile an, das ist die x-Achse. Dann geben wir noch die Anzahl der Zeilen an, also die Anzahl an Werten auf der y-Achse:

Auf diese Weise kann man sich das Ganze wie eine Tabelle vorstellen.

Wir haben hier nun also ein 2D-Array mit dem Namen „products“ erstellt, welches zwei Spalten und drei Zeilen besitzt. Also drei Zeilen mit jeweils zwei Spalten. In jeder Zeile befindet sich in der ersten Spalte immer der Produktname.

In der Spalte 0 von Zeile 0 haben wir beispielsweise den Namen „Senf“ als Produktnamen geschrieben. In der Spalte 1 von Zeile 0 befindet sich der Produkttyp Lebensmittel:

Wie bei eindimensionalen Arrays siehst du, dass in C# 2D Arrays ebenfalls jeweils immer bei Index 0 beginnen. Der 0te Index ist also immer der erste Index.

Das habe ich in diesem Beispiel mit drei verschiedenen Zeilen umgesetzt. Ich habe also zu diesem products-Array drei Produkte mit jeweils einem Produkttyp hinzugefügt.

In Spalte 0, Zeile 1 sehen wir den Produktnamen „Smartphone“ und in Spalte 1 von Zeile 1 haben wir dessen Produkttyp, nämlich Elektronik:

Zu guter Letzt haben wir noch Spalte 0 von Zeile 2 mit dem Produktnamen „Schokolade“ und in Spalte 1 von Zeile 2 den Produkttyp Lebensmittel:

Weil das Ganze so nun etwas verwirrend aussieht, habe ich es noch einmal auf eine andere Art visualisiert:

Man kann sich in C# 2D Arrays im Grunde wie eine Tabelle vorstellen, die zwei Dimensionen besitzt. Diese enthält verschiedene Zellen, also Spalten, in die man Werte eintragen kann.

1.1. Genauere Erläuterung der Tabelle

Spalte 0 von Zeile 0 ist der Produktname „Senf“.

Spalte 1 von Zeile 0 ist der Produkttyp Lebensmittel.

Spalte 0 von Zeile 1 ist der Produktname „Smartphone“.

Spalte 1 von Zeile 1 ist der Produkttyp Elektronik.

Spalte 0 von Zeile 2 ist der Produktname „Schokolade“.

Und zuletzt befindet sich in Spalte 1 von Zeile 2 der Produkttyp Lebensmittel.

Damit das Thema noch verständlicher erscheint, sehen wir uns die 2D Arrays nun einmal in der Praxis in Visual Studio an.

2. C# 2D Arrays in der Praxis

Wie erstellt man ein zweidimensionales Array? Man erzeugt C# 2D Arrays im Grunde genau wie 1D Arrays, allerdings setzt man zusätzlich ein Komma zwischen das eckige Klammerpaar.

2.1. 2D Arrays erzeugen

Wenn wir jetzt also beispielsweise ein 2D-Array aus Strings erstellen möchten, dann schreiben wir einfach den Datentyp String, das eckige Klammerpaar und ein Komma zwischen die Klammern. Damit legen wir fest, dass es sich nicht um ein 1D-Array, sondern um ein 2D-Array handelt:

Man kann in C# 2D Arrays natürlich auch von verschiedenen Datentypen erstellen. Das heißt, es sind nicht nur Strings möglich, sondern auch Integer, Decimals, Booleans und jeder beliebige selbsterstellte Datentyp auch, den man in Form einer Klasse definiert hat.

Jetzt muss man diesem Array natürlich noch einen Namen geben. Ich nenne es wieder „products“, wie bereits im vorherigen Beispiel:

Dann erstellen wir das Arrayobjekt. Wie machen wir das? Wie bei 1D-Arrays auch: Wir schreiben erst mal das Schlüsselwort new und anschließend wieder das Wort „string“, dann setzen wir ein eckiges Klammerpaar:

Die Größen der Dimensionen müssen wir an dieser Stelle noch innerhalb des Klammerpaars vor und nach dem Komma angeben.

Zuerst müssen wir angeben, wie viele Werte es auf der x-Achse jeweils gibt. Also wie viele Spalten dieses Array pro Zeile besitzt.

Für unser Praxisbeispiel legen wir jetzt zwei Spalten pro Zeile fest. Dann folgt das Komma und anschließend geben wir die Größe der y-Achse an. Das heißt, wie viele Werte wir auf der y-Achse haben, also über wie viele Zeilen diese Tabelle verfügt.

Hierfür legen wir einmal drei Zeilen fest. Dann schließen wir die Zeile mit einem Semikolon ab:

Und damit haben wir jetzt ein String Array namens products erstellt, welches zwei Dimensionen hat! Und zwar zwei Spalten jeweils auf drei Zeilen.

2.2. Werte an 2D Arrays zuweisen

Ab diesem Punkt ist der Umgang mit 2D-Arrays eigentlich exakt derselbe wie der mit 1D-Arrays. Nur dass wir beim Adressieren eines Wertes nicht nur einen Index angeben müssen, also eine Zahl für den Index, sondern die Koordinaten des Wertes in diesem 2D-Array.

Wir müssen also angeben, in welcher Spalte von welcher Zeile sich ein Wert befindet.

Den Wert von products Spalte 0 von Zeile 0 setzen wir beispielsweise einmal auf „Apfel“.

Wir geben also erst die Koordinate auf der x-Achse an und anschließend die Koordinate auf der y-Achse.

In Spalte 0 von Zeile 0 haben wir also den Wert Apfel geschrieben. Welcher Produkttyp ist ein Apfel? Es ist ein Lebensmittel, das heißt, wir schreiben in Zeile 0 von Spalte 1 den Produkttyp „Lebensmittel“:

Nun haben wir in Spalte 0 von Zeile 0 den Namen Apfel und in Spalte 1 von Zeile 0 den Produkttyp Lebensmittel.

Genauso können wir das nun auch bei anderen Produkten umsetzen. In Zeile 1 von Spalte 0 schreiben wir zum Beispiel „Computer“. Den Produkttyp „Elektronik“ legen wir für Spalte 1 von Zeile 1 fest:

Zu guter Letzt schreiben wir in Spalte 0 von Zeile 2 „Brot“ als weiteres Lebensmittel und den Produkttyp „Lebensmittel“ in Spalte 1 von Zeile 2:

Wie du gesehen hast, funktioniert bei den 2D-Arrays das Zuweisen der Werte genau wie bei den eindimensionalen Arrays. Der Unterschied besteht darin, bei den zweidimensionalen Arrays zwei Werte für die Koordinaten angeben zu müssen.

2.3. Werte von 2D Arrays lesen

Das Lesen der Werte funktioniert im Grunde genauso.

Dafür setzen wir unter den Code ein Console.WriteLine und lassen uns die erste Produktzeile einmal ausgeben. Zuerst lassen wir den Produktnamen „Apfel“ ausgeben. Dafür schreiben wir die folgende Zeile:

Bei der Ausgabe sehen wir nun den Namen Apfel:

An dieser Stelle können wir noch einen Trennstrich hinzufügen sowie die Koordinaten für Spalte 1 von Zeile 0, damit uns das Programm auch den Produkttyp in der Konsole ausgibt:

Und das können wir jetzt natürlich mit den anderen Zeilen auch machen. Lassen wir also beispielsweise einmal Spalte 0 von Zeile 1 und Spalte 1 von Zeile 1 ausgeben, dann sehen wir Computer | Elektronik in der Konsole:

Wenn wir Spalte 0 von Zeile 2 und Spalte 1 von Zeile 2 ausgeben lassen, dann haben wir Brot und Lebensmittel in der Konsole stehen:

Gar nicht mal so schwierig! Du hast nun also gelernt, wie man mit zweidimensionalen Arrays arbeitet und wie diese aufgebaut sind. Da man die C# 2D Arrays in der Praxis häufig benötigt, empfehle ich dir, noch etwas damit herumzuexperimentieren. So kannst du das Thema verinnerlichen.

Im Grunde haben wir es dabei mit keinem sehr schwierigen Thema zu tun, da es sich um eine Tabelle aus Werten handelt. Auf die Spalten der Zeilen kann man zugreifen, indem man im eckigen Klammerpaar die Koordinaten dafür angibt.

Inhaltsverzeichnis

1. Was sind C# Arrays?

Arrays sind aus der Programmierung nicht wegzudenken, da wir sie im Alltag immer wieder gebrauchen können. Doch was sind Arrays eigentlich?

Ein C# Array kannst du dir wie eine Variable vorstellen, die mehrere Werte auf einmal beinhalten kann.

Anders gesagt ist ein Array mit einem Schrank vergleichbar, der mit mehreren Schubladen ausgestattet ist. In jeder dieser Schubladen befindet sich ein bestimmter Wert. Diese Werte kann man aus den einzelnen Schubladen herausnehmen und wieder hineinlegen. Oder sich die Werte lediglich anschauen.

Bei Arrays handelt es sich um die einfachste Datenstruktur in der Programmierung. Viele komplexere Datenstrukturen bauen zudem auf den Arrays auf.

1.1. Was ist eine Datenstruktur?

Eine Datenstruktur kannst du dir wie eine strukturierte Sammlung von Daten vorstellen. Davon gibt es zahlreiche verschiedene Arten, die Daten auf unterschiedliche Art und Weise speichern und verwalten. Arrays sind, wie bereits erwähnt, so ziemlich die einfachste Art davon.

Dabei gibt es in C# Arrays unterschiedlicher Art. Auf der einen Seite sind das die eindimensionalen Arrays, die du dir wie eine eindimensionale Liste aus Werten vorstellen kannst. Auf der anderen Seite gibt es die zweidimensionalen Arrays, unter welchen man Tabellen aus Werten mit Zeilen und Spalten versteht.

Wir sehen uns zum Einstieg nun die 1D-Arrays an, da diese simpel sind und wir sie am häufigsten benötigen.

2. Was ist ein 1D-Array?

Ein 1D-Array ist eine einfache Liste von Werten. Jeder darin enthaltene Wert kann über seinen sogenannten Index, also seine Position im Array, gelesen oder überschrieben werden.

Über den Index können wir also sozusagen auf die Schublade zugreifen, in der sich ein bestimmter gesuchter Wert befindet.

In der folgenden Abbildung siehst du ein Beispiel für ein im C# Code verwendetes Array:

Wie du sehen kannst, wurde zunächst ein Array definiert. Der Unterschied zur Variablendefinition ist der, dass nach dem Datentyp noch ein eckiges Klammerpaar angehängt wird. Die Array-Instanz wird über „new string[4]“ erzeugt und mithilfe des Zuweisungsoperators an „namen“ zugewiesen.

Die Vier drückt aus, dass ich in dieses Array vier String Werte speichern möchte.

Wenn man C# Arrays erstellt, muss bei der Erzeugung immer direkt eine gewünschte Größe spezifiziert werden. Diese ist fix und lässt sich nicht mehr ändern. Wenn ich also in unserem Beispiel im Array mit dem Bezeichner „namen“ die Zahl 4 zwischen die eckigen Klammern schreibe, kann ich in dieses vier verschiedene Werte speichern.

Auf die einzelnen Indizes (Indizes ist der Plural von Index), also die Positionen bzw. Schubladen im Array kann ich zugreifen, indem ich den Namen des Arrays und den jeweiligen Index schreibe. Beispiel: namen[0]

C# Arrays fangen bei 0 zu zählen an. Das heißt, Index 0 ist immer der erste Index in einem Array. In Index 0 schreibe ich in unserem Beispiel den Wert Alina. In Index 1, also den zweiten Wert, schreibe ich Lasse, in den dritten Wert Jens und in den vierten den Namen Sabine.

Wie du siehst, kann man in diese Indizes genauso einfach Werte schreiben wie auch bei Variablen. Man gibt dafür lediglich das Array an und schreibt den gewünschten Index, den man ansprechen möchte, mit dem eckigen Klammerpaar und der Zahl. So verhält es sich im Grunde auch beim Lesen von Werten.

Außerdem kann ich den Wert des Array Indexes auch lesen, indem ich schreibe Console.WriteLine(namen[0]).

Damit würde ich in der Konsole den Namen Alina ausgeben lassen. Das funktioniert also wie bei ganz normalen Variablen auch, nur dass wir immer noch den Index in dem eckigen Klammerpaar an den Variablennamen anhängen müssen.

Das sind also im Grunde eindimensionale C# Arrays. Nun möchte ich dir das Ganze noch Schritt für Schritt an einem weiteren Praxisbeispiel in Visual Studio zeigen. Die zweidimensionalen Arrays sehen wir uns dann im nächsten Blogartikel an, da das Thema hier den Rahmen sprengen würde.

3. 1D-Arrays in der Praxis

Wie funktionieren Arrays jetzt also in der Praxis? Gerade haben wir gelernt, was ein Array ist. Nämlich im Grunde eine Variable, die mehrere Werte auf einmal fassen kann.

Arrays kann man in C# von jedem beliebigen Datentyp erstellen. Das heißt, ich kann nicht nur wie eben im Beispiel gezeigt, ein Array aus Strings erstellen, sondern beispielsweise auch ein Array aus Integern. Genau das werden wir jetzt einmal umsetzen.

Wie bereits gelernt, erstellt man ein Array wie eine Variable, allerdings fügt man noch ein eckiges Klammerpaar an.

Das heißt: Zuerst schreiben wir den Datentyp, anschließend folgt das eckige Klammerpaar. Damit sagen wir, dass wir nicht nur einen einfachen Integer Wert erstellen möchten, sondern ein Array aus Integern.

Damit haben wir unser Array namens numbers also erstellt und können den einzelnen Indizes, anders gesagt den Schubladen dieses Arrays, auch schon Werte zuweisen. Wie machen wir das nun?

Um auf einen Index von numbers zugreifen zu können, geben wir diesen innerhalb des eckigen Klammerpaars an. Der erste Index eines C# Arrays ist wie gesagt immer der Index 0. Beim Index 0 weise ich einfach mal den Wert 10 zu:

Das heißt, innerhalb des Arrays an der Position mit dem Index 0 steckt jetzt der Wert 10.

An dieser Stelle kann ich natürlich auch noch die anderen Indizes mit Werten befüllen. In Index 1 schreibe ich den Wert 20, in Index 2 den Wert 25 und in den letzten Index 3, da wir das Speichern von vier Werten festgelegt haben, schreibe ich 30:

Damit haben wir dem Array numbers die Werte zugewiesen. Wie bei normalen Variablen auch, haben wir auf diese Indizes eines C# Arrays nicht nur einen schreibenden, sondern auch einen lesenden Zugriff.

Das bedeutet, ich kann zum Beispiel Console.WriteLine(numbers[2]) schreiben:

Beim Ausführen des Programms erhalten wir damit den Wert 25 in der Konsole, da ich diesen in Index 2 vom numbers Array geschrieben habe:

Wenn ich den Index nun einfach mal auf 3 ändere, sehen wir den Wert 30 in der Konsole:

Die Arbeit mit Array Indizes verhält sich also genauso wie die Arbeit mit ganz normalen Variablen. Du hast also gelernt, wie man ein Array erstellen kann und wie man die einzelnen Indizes zuweisen und lesen kann.

Jetzt möchte ich dir noch zeigen, wie du direkt bei der Erzeugung eines C# Arrays die Werte zuweisen kannst, ohne vorher eine Größe bzw. die Indizes einzeln spezifizieren zu müssen. Wenn du schon von Beginn an weißt, welche Werte du zuweisen möchtest, kannst du die Größe nämlich auch weglassen.

Stattdessen setzt man nach new int[] ein geschweiftes Klammerpaar, zwischen welches man die Werte schreiben und direkt zuweisen kann. Für Index 0 wähle ich den Wert 10, für Index 1 den Wert 20, für Index 2 den Wert 30 und für Index 3 den Wert 40. Dann schließen wir das Ganze mit einem Semikolon ab:

Möchten wir jetzt beispielsweise Index 3 ausgeben lassen, erhalten wir den Wert 40. Denn das ist schließlich Index 3:

Die Größe dieses C# Arrays ist vier, weil wir vier Werte zugewiesen haben. Ganz wichtig ist, dass man versteht, dass die Größe so eines Arrays fix ist.

Das heißt: Wenn wir das Array einmal erstellt und Werte zugewiesen haben, können wir die Größe des Arrays nicht mehr verändern. Ich kann nun also bei diesem Array niemals einen fünften Wert zuweisen. Stattdessen müsste ich ein neues Array Objekt erstellen.

An dieser Stelle sind wir auch schon am Ende des heutigen Beitrags angekommen. Du hast gesehen, was Arrays sind und die eindimensionalen Arrays auch direkt in der Praxis kennengelernt.

Nun macht es Sinn, damit etwas herumzuexperimentieren, damit du das Thema verinnerlichen kannst und somit den zweidimensionalen Arrays gewappnet bist.

Inhaltsverzeichnis

1. Wofür benötigen wir Benutzereingaben?

In der Praxis kommt es oftmals vor, dass wir in der Konsole eine Eingabe des Benutzers abfragen müssen. Zum Beispiel wenn es darum geht, einen Benutzernamen oder ein Geburtsdatum in ein Programm einzugeben. Neben diesen Beispielen existieren natürlich noch zahlreiche weitere.

Du siehst also: Die Benutzereingabe ist ein ziemlich wichtiges und spannendes Thema.

2. Die C# Console ReadLine Methode

Für die Abfrage einer Benutzereingabe in der Konsole verwendet man in C# Console ReadLine. Dabei handelt es sich um eine Methode, die den Eingabestrom als einen String liest, bis der Benutzer die Enter-Taste drückt und damit einen Zeilenumbruch auslöst.

Die Eingabe, die der Benutzer in die Konsole schreibt, gibt Console.ReadLine() als String zurück. Damit du dir das Ganze besser vorstellen kannst, sehen wir uns die Thematik einmal anhand eines Beispiels in Visual Studio an.

Wie bereits erwähnt, lesen wir mithilfe der C# Console ReadLine Methode den Eingabestrom des Benutzers. Also genau das, was der Benutzer in die Konsole eingibt. Erst wenn dieser Enter drückt, ist der Eingabestrom beendet. Das Gelesene geben wir an den Aufrufer zurück, wodurch wir es verarbeiten können.

In der Praxis können wir das zum Beispiel folgendermaßen umsetzen:

Zunächst erzeugen wir eine Variable namens "eingabe". Dieser Variable weisen wir den Rückgabewert der C# Console ReadLine Methode zu.

Anschließend schreiben wir Console.WriteLine und trennen das Ganze mit einer Strichlinie von dem, was wir ausgeben lassen möchten. Für unser Beispiel lassen wir nun dreimal die Eingabe des Nutzers ausgeben:

Beim Starten des Programms sehen wir, dass in der Konsole zunächst nichts steht. Das liegt eben daran, weil wir direkt in der ersten Anweisung die C# Console ReadLine Methode aufgerufen haben.

Das heißt, dass das Programm an dieser Stelle stoppt und den Eingabestrom abfragt. Der Benutzer, in diesem Fall also wir, müssen nun etwas in die Konsole eingeben. Ich gebe hier nun „Mein Name ist Janek“ ein.

Wenn ich anschließend auf Enter drücke, wird das Programm weiter abgearbeitet und gibt tatsächlich dreimal den String „Mein Name ist Janek“ unter der Strichlinie aus:

Zusammengefasst arbeitet die C# Console ReadLine Methode also wie folgt: Sobald die C# Console ReadLine Methode aufgerufen wird, stoppt das Programm und fordert den Nutzer auf, etwas über die Konsole einzugeben. Das Programm liest die Eingabe als String ein und sobald wir Enter drücken, gibt die Methode den eingegebenen Wert als String zurück. In diesem Fall wird er direkt an die Variable eingabe zugewiesen. Den in der Variable gespeicherten Wert können wir nun entsprechend in unserem Programm weiterverarbeiten.

2.1. Einen Benutzernamen abfragen

An dieser Stelle möchte ich dir nun zeigen, wie die Abfrage eines Benutzernamens beispielsweise aussehen kann.

Dafür lassen wir zunächst einmal in der Konsole ausgeben: „Gebe einen Benutzernamen ein:“. Anschließend soll man direkt in derselben Zeile seinen Namen eingeben können. Diesen Namen soll das Programm dann in der Konsole ausgeben.

Wie setzen wir das am besten um? Zuerst brauchen wir eine String Variable für den Usernamen. Diese deklarieren wir und schreiben anschließend „Gebe deinen Benutzernamen ein:“.

Jetzt möchten wir aber, dass man als Benutzer seinen Namen nicht in der nächsten Zeile eingibt, sondern noch in derselben. Um das umzusetzen, ist es ganz wichtig, nicht Console.WriteLine() zu schreiben, weil das automatisch einen Zeilenumbruch auslöst.

Stattdessen schreiben wir lediglich Console.Write(). Wenn wir „Write“ schreiben, kommt es zu keinem Zeilenumbruch. Mit dem Zusatz „Line“ hingegen schon. Damit wir also direkt nach dem Doppelpunkt unseren Namen eingeben können, verwenden wir Console.Write:

Nun möchten wir den Namen abfragen und in die Variable username schreiben. Doch wie gehen wir hierfür vor? Ganz einfach:

Somit liest das Programm den Benutzernamen ein und mit Drücken der Enter-Taste speichert es den gelesenen String in die Variable username.

Anschließend können wir in der Konsole den String „Hallo“ und zusätzlich den eingegebenen Usernamen ausgeben lassen:

Wenn wir jetzt das Programm starten, sehen wir zunächst die Aufforderung, einen Benutzernamen einzugeben:

Wenn ich an dieser Stelle beispielhaft „Janek“ eingebe und Enter drücke, sehen wir in der Konsole „Hallo Janek“:

Jetzt weißt du also, wie man String Werte in der Konsole vom Benutzer abfragen kann. Allerdings wollen wir natürlich nicht nur String Werte lesen, sondern auch Werte von anderen Datentypen.

Zum Beispiel könnten wir das Programm so erweitern, dass der Benutzer auch noch sein Alter eingeben soll. Das Alter schreiben wir dann in eine Variable vom Typ Integer und nennen diese age.

Wie gehen wir nun vor? Wir können in diesem Fall nicht wie im vorherigen Beispiel age = Console.ReadLine schreiben, da in C# Console ReadLine einen String Wert zurückgibt. Die Variable age ist allerdings vom Datentyp Integer und ein String lässt sich schließlich nicht in einen Integer speichern. Das Problem können wir dennoch auf eine andere Art und Weise lösen.

Dafür löschen wir nun die Ausgabe mit Console.WriteLine(“Hallo “ + username) und schreiben noch zusätzlich, dass man sein Alter eingeben soll:

Danach möchten wir in die Variable age das speichern, was uns das Programm durch Console.ReadLine zurückgibt:

Wie du siehst, erhalten wir jetzt einen Fehler. Denn wie bereits erwähnt, gibt in C# Console ReadLine einen String zurück.

Das heißt: Das, was uns als String zurückgegeben wird, müssen wir noch irgendwie in einen Integer konvertieren. Und genau dafür gibt es eine sehr nützliche Klasse im .NET-Framework, die sich „Convert“ nennt.

3. Die Convert-Klasse

Die Convert-Klasse enthält zahlreiche Methoden.

Mit einer davon können wir beispielsweise einen String Wert in einen Integer konvertieren. Das funktioniert mit Convert.ToInt32(). Wir möchten also das, was wir als Parameter übergeben, in einen 32 Bit Integer konvertieren.

Zur Info: Bei dem 32 Bit Integer handelt es sich im Grunde einfach um den normalen Datentyp int.

In unserem Beispiel übergeben wir nun als Parameter den String Wert, den wir konvertieren möchten. Und das ist wiederum der Wert, den wir über die Konsole mit Console.ReadLine() entgegennehmen. Der konvertierte Wert wird anschließend der Variable age zugewiesen:

Dadurch ist nun sichergestellt, dass es bei der Programmausführung zu keinem Fehler kommt.

Zum Schluss können wir die Werte dann noch auf der Konsole ausgeben lassen.

Starten wir das Programm jetzt erneut, werden wir dazu aufgefordert, einen Benutzernamen und anschließend ein Alter einzugeben:

Wenn wir das tun, erhalten wir im Nachhinein die folgende Ausgabe und sehen, dass es einwandfrei funktioniert:

Du hast also hier noch einmal gesehen, wie man mithilfe der Convert-Klasse einen Integer Wert aus einem String Wert erzeugen und somit den String in einen Integer konvertieren kann.

Die Convert-Klasse hat natürlich nicht nur für 32 Bit Integer Convert-Methoden, sondern auch für viele andere Datentypen, die man sich bei Bedarf noch ansehen kann.

Inhaltsverzeichnis

1. Was sind Methoden?

Mit Methoden können wir Code schreiben, welchen wir immer wieder aufrufen können, ohne ihn neu schreiben zu müssen. C# Methoden haben dabei einen Namen, eine Parameterliste, einen Codeblock und in manchen Fällen auch einen Rückgabewert.

Der Name ist deshalb wichtig, weil wir über diesen den dazugehörigen Codeblock immer wieder erneut aufrufen können.

Über die Parameterliste können wir der Methode Werte mitgeben, mit welchen wir dann intern im Codeblock arbeiten können.

Der Codeblock selbst stellt den Inhalt der Methode dar und spiegelt wieder, was passiert, wenn wir die Methode ausführen. Darin befindet sich also der ganze Code.

Beim Rückgabewert handelt es sich um das, was die Methode sozusagen als Ergebnis wieder zurückliefert.

Was das Ganze bedeutet, wirst du aber gleich noch genauer anhand eines Beispiels sehen.

Allgemein kann man sagen, dass es uns C# Methoden ermöglichen, unseren Code in kleinere Abschnitte aufzuteilen. Somit gestalten sie unseren Code übersichtlich und wartbar. Dabei handelt es sich um einen wichtigen Vorteil, den uns Methoden bzw. Funktionen allgemein in der Programmierwelt bieten.

Methoden sind im Grunde Funktionen, falls dir das Wort „Funktion“ bereits etwas sagt. Funktionen nennt man in der objektorientierten Welt allerdings Methoden. In der nicht objektorientierten Welt hingegen bleibt der Name bei „Funktion“.

Es existieren also zwei unterschiedliche Namen für sehr ähnliche Dinge. Falls dir jetzt allerdings das Wort „Funktion“ auch nichts sagen sollte, ist das ebenfalls kein Problem. Wir werden uns jetzt nämlich die C# Methoden anhand von Beispielen ansehen.

2. C# Methoden ohne Rückgabewert

Zuerst werden wir uns eine Methode ohne Rückgabewert ansehen. Wie du im folgenden Bild sehen kannst, befinden wir uns in der Klasse Program, die bereits am Anfang generiert wurde:

Darin sehen wir die Main-Methode, bei der es sich, wie der Name schon verrät, auch um eine Methode handelt.

Unterhalb der Main-Methode haben wir eine eigene Methode definiert: die GreetUser-Methode. Dieser kann man einen String namens username übergeben, wenn man sie aufruft. Das Programm gibt dann in der Konsole aus „Hallo username. Wie geht es dir?“.

Wie du siehst, können wir diese GreetUser-Methode auch über ihren Namen (GreetUser) in der Main-Methode aufrufen und dort einen Parameter mitgeben.

Im Beispiel habe ich den Namen Peter für den String username übergeben. So gibt das Programm in der Konsole aus „Hallo Peter, wie geht es dir?“.

Damit haben wir ein einfaches Beispiel für eine Methode.

Wie du sehen kannst, habe ich auch das Schlüsselwort „static“ angehängt. Das liegt daran, dass wir die Methode in der class Programm definieren und wir sie ohne Objekt, also ohne eine Objektinstanz aufrufen können möchten. Das geht nun alles schon etwas in die objektorientierte Programmierung über. So weit wollen wir jetzt aber noch nicht denken, versuche also im Moment noch, das „static“ gedanklich auszublenden. Was static genau bedeutet, wirst du in der Zukunft noch erfahren.

Dann folgt ein „void“. Das Schlüsselwort void bedeutet einfach, dass die Methode kein Ergebnis als Rückgabewert zurückliefert.

Anschließend kommt der Name der C# Methode, in diesem Fall also GreetUser, gefolgt von einem Klammerpaar. Das Klammerpaar müssen wir immer mit dazu schreiben. Dieses beinhaltet die sogenannte Parameterliste. Falls man keine Parameter annehmen möchte, setzt man lediglich ein leeres Klammerpaar. Mehrere Parameter hingegen trennt man innerhalb der Klammern mit einem Komma voneinander.

Als Parameter haben wir, wie bereits erwähnt, den String username. Dieser ist im Grunde eine Variable, die wir in unserer C# Methode verwenden. Im Code des Beispiels nutzen wir diese Variable username dann auch und können ihr über den Parameter einen Wert übergeben. Im Falle unseres Beispiels habe ich den String „Peter“ übergeben.

Wie du siehst, ist das Ganze eigentlich ziemlich einfach.

3. C# Methoden mit Rückgabewert

Sehen wir uns nun aber mal ein Beispiel einer C# Methode mit Rückgabewert an:

In diesem Beispiel sehen wir wieder die Main-Methode und unter dieser eine static double RectangleArea-Methode. Doch was ist das?

Ich habe eine Methode erstellt, die RectangleArea heißt und wie der Name es schon vermuten lässt, kann man mit dieser den Flächeninhalt von einem Rechteck berechnen. Man übergibt darin mit dem double width (Breite) und double height (Höhe) Parameter. Das heißt eine Breite und eine Höhe jeweils vom Typ Double. In der Methode schreiben wir, dass mit dem Schlüsselwort return ein Wert an den Aufrufer zurückgegeben werden soll. Dieser Wert ist das Ergebnis, das wir aus der Rechnung width * height erhalten.

Wie du vielleicht schon gesehen hast, habe ich bei dieser Methode nicht void, sondern double geschrieben, da der Rückgabewert vom Typ double ist. Das müssen wir vor dem Methodennamen angeben, um auch mit return dann einen double zurückgeben zu können.

Würden wir hingegen void anstelle von double schreiben, könnten wir einen double nicht mit return zurückgeben.

In der Main-Methode rufe ich das Ganze dann auf, indem ich einen double namens „area“ erstelle. Diesem weise ich dann das zu, was RectangleArea mit den beispielhaften Werten 8 und 5 für die Breite (width) und die Höhe (height) zurückgibt. Das heißt, ich lasse hier die Fläche eines Rechtecks berechnen, das die Maße 8 und 5 hat.

Das Ergebnis, also den Flächeninhalt, schreibt das Programm dann in die Variable „area“. Zu guter Letzt lasse ich die Fläche über Console.WriteLine ausgeben.

Das sind also C# Methoden! Sehen wir uns nun das Ganze noch einmal in der Praxis in Visual Studio an.

4. C# Methoden ohne Rückgabewert in der Praxis

Beginnen wir hierfür mit einer Methode ohne Rückgabewert. Wie definiert man eine Methode? Zuerst geht man in eine Klasse, in der man die Methode definieren möchte. Da wir hier nur die Klasse Program haben, gehen wir in deren Codeblock. In der Klasse Program befindet sich auch die Main-Methode, unter welcher wir nun eine eigene Methode schreiben.

Doch wie definieren wir jetzt in der Klasse Program eine Methode? Wir müssen hierfür zunächst eine statische Methode definieren, damit diese nicht nur über eine Objektinstanz aufgerufen werden kann. Wie gesagt, geht das schon etwas in die objektorientierte Programmierung, die wir noch nicht behandelt haben. Trotzdem müssen wir das „static“ in diesem Fall einfach mit angeben.

Was statische Methoden sind bzw. was dieses Schlüsselwort „static“ allgemein bedeutet, wirst du später lernen.

Nun müssen wir also im Grunde nur die Methode definieren. An erster Stelle legt man den Rückgabetyp der Methode fest. Man kann also angeben, von welchem Datentyp der Wert ist, den die Methode zurückgibt.

Da wir allerdings zuerst eine Methode ohne Rückgabewert erstellen möchten, schreiben wir an der Stelle einfach void. Somit gibt sie nichts zurück:

Nun müssen wir der Methode einen Namen geben. Wir nennen diese einfach mal PrintMultipleMessages, womit wir sagen wollen „gebe mehrere Nachrichten in der Konsole aus“.

Neben den Namen setzen wir nun ein Klammerpaar, zwischen welches wir Parameter schreiben können. Das ist kein Muss, allerdings möchten wir für dieses Beispiel tatsächlich Parameter annehmen. Dafür wählen wir einen String, bei dem es sich um die Message handelt, die das Programm ausgeben soll und einen Integer für die Anzahl der Messages. Also wie oft wir die Message in der Konsole ausgeben lassen möchten. Diesen nennen wir jetzt einfach mal „count“.

Anschließend setzen wir das geschweifte Klammerpaar, zwischen welches wir den Code der Methode schreiben werden:

Im Codeblock schreiben wir dann while (count > 0), also so lange die Variable count einen größeren Wert als die Zahl 0 hat, möchten wir mit Console.WriteLine die Message ausgeben lassen und count mit jedem Durchlauf um 1 verringern:

Damit ist die Methode PrintMultipleMessages auch schon fertig. Jetzt können wir sie zum Beispiel oben in der Main-Methode aufrufen.

Um das umzusetzen, rufen wir sie über ihren Namen PrintMultipleMessages auf, setzen ein Klammerpaar und übergeben dann in diesem die Parameter message und count. Für den Parameter message wählen wir „Hallo Welt“ und schreiben nach einem Komma für den Parameter count den Wert 3.

So soll das Programm die Message dreimal ausgeben:

Wenn wir das Programm nun ausführen, sehen wir Folgendes in der Konsole:

Das Schöne an Methoden ist, dass wir deren Codeblöcke immer wieder aufrufen können, ohne sie neu schreiben zu müssen. Auch die Parameter können wir für jede Methode individuell wählen.

Wir könnten also zum Beispiel, nachdem wir 3-mal „Hallo Welt“ ausgegeben haben, über die gleiche Methode eine andere Message ausgeben lassen. Das kann beispielsweise „Hello World!“ sein, welches wir diesmal 10-mal ausgeben lassen:

Wie du siehst, haben hier nun folgendes Ergebnis in der Konsole:

Zuerst gibt das Programm 3-mal das deutsche „Hallo Welt“ aus und danach folgt der nächste Aufruf mit dem „Hello World!“, welches 10-mal in der Ausgabe erscheint. Es funktioniert also einwandfrei. Wir können das, was wir in diese Methode geschrieben haben also immer wieder verwenden.

Aus diesem Grund können wir mithilfe von C# Methoden unseren Code weitaus besser und wartbarer strukturieren. So können wir nämlich mehrere Methoden definieren, die alle jeweils ihre eigenen Aufgaben erfüllen. Wir haben also nicht den gesamten Code in der Main-Methode, sondern wir lagern so verschiedene Aufgaben in mehrere Methoden aus, die wir dann entsprechend aufrufen können, wenn wir sie benötigen.

Wenn wir an diesen Methoden etwas ändern möchten, müssen wir lediglich an die Stelle der Methode springen, an der wir sie definiert haben und können sie dort anpassen. So müssen wir nicht in einem riesigen Codeblock danach suchen.

Das war also ein Beispiel für C# Methoden ohne Rückgabewert. Nun sehen wir uns noch eines für Methoden mit Rückgabewert an.

5. C# Methoden mit Rückgabewert in der Praxis

Methoden mit Rückgabewert sind im Grunde genauso einfach zu definieren wie Methoden ohne Rückgabewert. Der Unterschied liegt darin, dass wir statt void einen Datentyp mitgeben müssen.

Wir erstellen nun also eine Methode mit Rückgabewert und nennen diese CheckAge. Mit dieser möchten wir prüfen, ob ein Benutzer über 18 ist.

Sollte das der Fall sein, gibt die Methode ein true zurück. Andernfalls ein false. Hierfür müssen wir also einen boolean Wert zurückgeben, also ein true oder ein false.

Wir schreiben also static und statt void wählen wir bool sowie den Namen CheckAge. Dieser Methode übergeben wir einen Integer:

Nun geben wir im Grunde nur ein true oder ein false zurück, je nachdem, ob der Wert der Variable age größer oder gleich 18 ist oder eben nicht.

Doch wie machen wir das?

Wenn wir etwas als Ergebnis von diesem Methodenaufruf zurückgeben oder auch „returnen“ möchten, nutzen wir das Schlüsselwort return. Diesem return müssen wir jetzt nur noch einen Wert mitgeben, den das Programm damit zurückgeben soll. Diesen Wert erhalten wir aus einem booleschen Ausdruck.

Wir möchten schließlich prüfen, ob age größer oder gleich 18 ist. Also schreiben wir: return age >= 18;

Das ist ein boolescher Ausdruck. Hier prüft das Programm, ob age größer oder gleich 18 ist. Wenn ja, gibt das Programm ein true zurück. Dieses true gibt die Methode dann mit return an den Aufrufer zurück. Wenn age nicht größer oder gleich 18 ist, erhalten wir ein false, welches die Methode ebenfalls zurückgibt.

Jetzt können wir im Grunde Folgendes machen:

In der Main-Methode können wir beispielsweise eine Variable namens age erstellen, die ein Alter repräsentiert und dieser den Wert 12 zuweisen. Anschließend schreiben wir if (CheckAge(age)), womit wir überprüfen, ob die Variable age größer oder gleich 18 ist.

Wenn wir hierbei ein true erhalten, lassen wir in der Konsole „Du bist volljährig“ ausgeben. Falls das hingegen nicht der Fall ist, lassen wir „Du bist minderjährig“ in der Konsole ausgeben:

Um zu sehen, was nun passiert, führen wir das Ganze einmal aus:

Da wir 12 beim Alter angegeben haben, gibt das Programm den Satz „Du bist minderjährig“ in der Konsole aus. Schreiben wir nun allerdings, dass das Alter bei 18 liegt, erhalten wir die Ausgabe „Du bist volljährig“:

Geben wir bei age den Wert 22 an, sehen wir ebenfalls den Satz „Du bist volljährig“ in der Konsole:

Das war also im Grunde ein weiteres Beispiel für eine C# Methode mit Rückgabewert. Statt dem Schlüsselwort void schreibt man einen Rückgabedatentyp, den man mit return auch zurückgeben kann.

An dieser Stelle sind wir auch schon am Ende dieses Beitrags über C# Methoden angekommen. Im nächsten Artikel werden wir uns ansehen, wie man Benutzereingaben in C# abfragen kann. Wenn das für dich interessant klingt, schau gerne wieder vorbei!

Inhaltsverzeichnis

1. Was sind Schleifen?

Eine Schleife ist ein Codeabschnitt, den das Programm mehrmals hintereinander ausführt. Man kann mit einer Schleife beispielsweise einen Codeabschnitt so lange ausführen lassen, bis eine bestimmte Bedingung erfüllt ist. Des Weiteren kann man mit Schleifen Datenstrukturen wie etwa Listen und Tabellen durchlaufen. Dazu aber mehr in einem späteren Artikel.

Wichtig zu wissen ist also, dass Schleifen dafür da sind, einen bestimmten Codeblock mehrmals hintereinander ausführen zu lassen, anstatt nur ein einziges Mal und anschließend beim nächsten Codeblock weiterzumachen.

Das ist tatsächlich sehr nützlich und findet in der Praxis sehr häufig Anwendung.

Wie ich bereits anfangs erwähnt habe, werden wir uns heute die While und die Do-While Schleife in C# ansehen. Es gibt also verschiedene Arten von Schleifen. Neben diesen beiden wirst du in naher Zukunft noch weitere Schleifen kennenlernen. Das sind zum Beispiel die for Schleife und die foreach Schleife.

Beginnen wir nun also mit der C# While Schleife.

2. Die C# While Schleife

Die While Schleife kann man sich wie eine if Abfrage vorstellen, nur dass diese so lange ausgeführt wird und sich immer wieder wiederholt, bis die Bedingung nicht mehr erfüllt ist.

Auf dem folgenden Bild siehst du ein einfaches Beispiel:

Wir haben eine Integer Variable namens zahl, die wir zunächst auf den Wert 1 gesetzt haben. Anschließend haben wir mit dem Schlüsselwort "while" eine While Schleife eingeleitet und wie bei einer if Abfrage auch ein Klammerpaar gesetzt, zwischen dem wir eine Bedingung bilden. Die Bedingung besagt hier, dass die Schleife so lange läuft wie die Variable zahl kleiner oder gleich dem Wert 10 ist.

Wenn wir beispielsweise nach der Ausführung des Codeblocks zahl um 1 erhöhen, prüft das Programm nochmals, ob die Bedingung immer noch erfüllt ist. Ist sie noch erfüllt, führt das Programm den Codeblock ein weiteres Mal aus.

Und dieser Prozess wiederholt sich so lange, bis die Bedingung schließlich ein false ergibt. Wenn die Bedingung false ist, geht es unter der Schleife weiter - der Codeblock wiederholt sich nicht mehr.

Wenn man die While Schleife auf Deutsch übersetzen würde, könnte man sagen:

Während diese Bedingung erfüllt ist, führe folgenden Code aus. Prüfe anschließend, ob sie immer noch erfüllt ist. Sollte das der Fall sein, führe den Code weiterhin aus, bis sie nicht mehr erfüllt ist.

Sehen wir uns nun einmal ein Praxisbeispiel in Visual Studio dazu an.

2.1. Die While Schleife in der Praxis

Um eine C# While Schleife zu erstellen, schreibt man das Schlüsselwort "while", gefolgt von einem Klammerpaar. In dieses Klammerpaar schreibt man wie bei einer if Abfrage auch eine Bedingung. Anders gesagt, einen booleschen Ausdruck, der ein true oder ein false zurückgibt.

Man kann also beispielsweise eine Integer Variable namens zahl erstellen, die ich anfangs auf den Wert 0 setze. Als Bedingung kann ich dann zum Beispiel formulieren: solange die Variable zahl kleiner ist als 100, erhöhe sie um 1 und gebe die Zahl anschließend aus:

Was passiert nun? Wenn wir das Programm starten, sehen wir die Zahlen von 1 bis 100 jeweils untereinander in der Konsole:

Der Codeblock wurde also 100-mal ausgeführt. Und genau dafür nutzen wir Schleifen – nämlich um Code mehrmals hintereinander ausführen zu können.

Bei While Schleifen ist es so, dass wir wie bei if Abfragen auch eine einfache Bedingung bilden können. Diese Bedingung prüft das Programm dann erneut, wenn die Schleife einmal durchlaufen ist. Ist sie immer noch erfüllt, führt das Programm den Codeblock nochmals aus. Das geht so lange, bis die Bedingung ein false zurückliefert.

Wir können im Übrigen auch Folgendes umsetzen:

Wir schreiben in den Codeblock Console.WriteLine(„Hallo Welt“) und formulieren im Kopf der While Schleife keine Bedingung, sondern setzen lediglich ein true zwischen die Klammern.

So legen wir fest, dass die Bedingung immer true und damit konstant erfüllt ist. Dementsprechend führt das Programm die Schleife unendlich lange aus, wie wir es in der Ausgabe erkennen können:

Hier haben wir somit eine Dauerschleife (Endlosschleife) erstellt. Es wird nun also unendlich oft „Hallo Welt“ ausgegeben. Bei While Schleifen besteht die Gefahr, in unendlichen Schleifen gefangen zu sein. Dass man das beachtet, ist also sehr wichtig.

Wenn man eine Endlosschleife vermeiden möchte, sollte man die Bedingungen so bilden, dass sie irgendwann ein false zurückgeben.

Neben der C# While Schleife existiert noch die sogenannte Do-While Schleife. Diese werden wir uns jetzt ansehen.

3. Die C# Do-While Schleife

Die C# Do-While Schleife funktioniert eigentlich genau wie die While Schleife mit dem Unterschied, dass diese die Bedingung nicht am Anfang, sondern am Ende überprüft.

Dadurch ist garantiert, dass das Programm die Schleife mindestens einmal durchläuft, egal ob deren Bedingung erfüllt ist oder nicht. Sehen wir uns nun auch die Do-While Schleife an einem Praxisbeispiel an.

3.1. Die Do-While Schleife in der Praxis

An der While Schleife, die wir bereits im vorherigen Beispiel erstellt haben, möchte ich dir den Unterschied zur Do-While Schleife zeigen. Bei der C# While Schleife ist es ja so, dass die Bedingung oben im Schleifenkopf geprüft wird.

Bei einer Do-While Schleife prüft das Programm die Bedingung hingegen am Ende des Codeblocks, also am Fuß der Schleife. Und das macht einen großen Unterschied.

Wenn wir nun beispielsweise die Variable zahl von Anfang an auf den Wert 20 setzen, wird die Bedingung dieser While Schleife kein einziges Mal erfüllt sein:

Wenn wir das Programm nun ausführen, sehen wir nichts in der Konsole:

Setzen wir den Wert der Variable zahl hingegen von Anfang an auf 0, bekommen wir tatsächlich die Zahlen von 1 bis 10 in der Konsole ausgegeben:

Wenn man bei einer normalen C# While Schleife von Anfang an die Bedingung nicht erfüllt, führt das Programm diesen Codeblock auch niemals aus.

Bei einer Do-While Schleife ist das jedoch anders. Die Do-While Schleife formuliert man in C# folgendermaßen:

Am Anfang des Codeblocks schreibt man das Schlüsselwort "do" und am Ende des Codeblocks schreibt man while gefolgt von einem Klammerpaar mit der Bedingung und einem Semikolon.

Wenn wir den Wert der Variable zahl vorerst auf 0 lassen, sehen wir immer noch die Zahlen von 1 bis 10 in der Konsole:

Setzen wir den Wert nun aber auf 20, führt das Programm den Code trotzdem mindestens einmal aus. Nun sehen wir in der Konsole den Wert 21:

Bei der While Schleife wäre diese 21 nicht zu sehen, denn bei dieser prüft das Programm schließlich bereits im Kopf die Bedingung. Das bedeutet, dass es zur Ausführung dieses Codeblocks niemals kommen wird.

Bei der Do-While Schleife führt das Programm, wie wir bereits gesehen haben, den Codeblock mindestens einmal aus.

Und damit sind wir auch schon am Ende dieses Beitrags angekommen! Ich hoffe, du hast verstanden, wie die C# While und die Do-While Schleife funktionieren.

In den kommenden Beiträgen werden wir uns noch weitere Schleifentypen ansehen. Es wird also noch wesentlich interessanter. Jetzt empfehle ich dir, selbst ein paar eigene Schleifen zu erstellen und mit diesen zu experimentieren, damit du das Ganze noch besser nachvollziehen kannst.

Inhaltsverzeichnis

1. Was sind C# switch Blöcke?

Bevor wir in das Thema eintauchen, sollten wir zunächst einmal die Frage beantworten, was denn switch Blöcke eigentlich sind.

Ähnlich wie mit if Abfragen können wir mit switch Blöcken den Programmablauf steuern. Anders jedoch als bei den if Abfragen, prüft das Programm dabei nicht auf eine Bedingung, sondern stattdessen eine Variable auf mehrere Konstanten.

Eine Konstante ist im Grunde ähnlich wie eine Variable mit dem Unterschied, dass ihr Wert unveränderbar ist. Eine Konstante ist also ein ganz bestimmter Wert. Mit einem switch Block können wir bei einer Variable überprüfen, ob diese denselben Wert hat wie mehrere festgelegte Konstanten innerhalb dieses switch Blocks.

Wie das genau aussieht, möchte ich dir an diesem einfachen Beispiel veranschaulichen:

Ganz oben auf der Abbildung haben wir eine Integer Variable namens „wochentag“, die ich auf den Wert 3 gesetzt habe. Anschließend leite ich mit dem switch-Schlüsselwort den C# switch Block ein und übergebe innerhalb eines Klammerpaars die Variable, die wir auf Konstanten überprüfen möchten. Dabei handelt es sich um die Variable wochentag, die ich bereits oben initialisiert habe. In den Kopf des switch Blocks gehört also die zu überprüfende Variable.

Anschließend folgt der Codeblock, in dem mehrere „cases“ definiert sind. Ein case, zu Deutsch ein Fall, ist im Grunde eine Konstante, auf die wir überprüfen.

Sehen wir uns als Beispiel einmal die Definition von case 1 an. Dieser wird eingeleitet mit dem Schlüsselwort case, gefolgt von der Konstante, also dem Wert, den dieser case haben soll und einem Doppelpunkt.

Alles, was nach dem Doppelpunkt folgt, führt das Programm dann aus, wenn die Variable wochentag den Wert 1 hat.

Das heißt: Wenn wir den switch Block einleiten, guckt das Programm erst, welche Variable auf verschiedene Konstanten geprüft werden soll. Im Fall unseres Beispiels ist das die Variable wochentag. Anschließend springt das Programm in den Block und überprüft die verschiedenen cases, bis es bei dem case ankommt, der für die Variable wochentag zutrifft.

Es prüft also zuerst bei case 1, ob wochentag den Wert 1 hat. Da wochentag jedoch den Wert 3 besitzt, steuert das Programm direkt zum nächsten case. Hier überprüft es, ob wochentag den Wert 2 hat. Da dies auch nicht der Fall ist, geht es weiter zu case 3, um zu überprüfen, ob wochentag diesen Wert besitzt. Da wochentag tatsächlich den Wert 3 hat, führt das Programm nun den Code dieses cases, den Console.WriteLine-Befehl, aus.

In der Konsole wird also „Mittwoch“ ausgegeben.

1.1. Das Schlüsselwort break

Dann gelangen wir zu einem break. Wie du sehen kannst, befindet sich ein break in jedem der cases. Wir nutzen es, um den case zu vollenden und den switch Block direkt zu verlassen, wenn das Programm den entsprechenden case ausgeführt hat.

Mit dem break können wir also wieder aus dem C# switch Block herausspringen.

Der Hintergrund hierfür ist, dass wir nach der Ausführung des zutreffenden cases nicht noch die danach folgenden cases sowie den default case ausführen lassen möchten.

1.2. Der default case

Den default case führt das Programm dann aus, sollte keiner der fest definierten cases zutreffen. Das heißt, wenn wochentag nicht den Wert 1, 2, 3, 4 oder 5 besitzt, führt es den default case aus. Im Beispiel lassen wir hierzu „ungültiger Wochentag“ in der Konsole ausgeben.

2. C# switch Blöcke in der Praxis

Um das Thema noch besser verstehen zu können, sehen wir uns die C# switch Blöcke nun mal in der Praxis anhand eines Beispiels an.

Hierfür erstellen wir eine Integer Variable mit dem Namen monat und setzen diese auf den Wert 3. Wir möchten nun einen switch Block bauen, der monat auf verschiedene Konstanten überprüft. Für die Konstanten wählen wir die Zahlen von 1 bis 12. Im Beispiel werde ich nicht alle Konstanten ausschreiben, da das den Rahmen dieses Beitrags sprengen würde. Die verbleibenden Konstanten kannst du in deinem Programm aber gerne als Übung selbst ergänzen.

Für jede Zahl, die wir haben, soll das Programm dann den entsprechenden Monat in Textform auf der Konsole ausgeben.

Für den Fall, dass monat den Wert 1 hat, legen wir in case 1 fest, dass das Programm „Januar“ auf der Konsole ausgeben werden soll. Um den case abzuschließen, setzen wir noch ein break.

Für den case 2 legen wir die Ausgabe „Februar“ fest und setzen auch hier ein break:

Für case 3, der auch der letzte dieses Beispiels sein wird, lassen wir in der Konsole „März“ ausgeben und setzen ebenfalls am Ende ein break:

Zu guter Letzt definieren wir noch den default case, der dann ausgeführt wird, wenn keiner der oben definierten cases zutrifft. Für diesen default case lassen wir auf der Konsole ausgeben „Ungültiger Monat“ und schreiben auch danach das Schlüsselwort break:

An dieser Stelle starten wir das Programm einmal, um zu sehen, was passiert. In der Variable monat befindet sich der Wert 3:

Wie wir sehen, gibt das Programm März in der Konsole aus. Das ist schließlich der dritte Monat und entspricht dem case 3.

Weisen wir der Variable monat den Wert 1 zu, gibt uns das Programm „Januar“ auf der Konsole aus:

Wenn wir etwas völlig anderes eingeben wie etwa 1234, gibt uns das Programm den default case und somit „Ungültiger Monat“ aus:

So viel zum Thema switch case in C#!

Die Switch-Blöcke verwenden wir vor allem dann, wenn wir eine bestimmte Variable auf mehrere verschiedene konstante Werte überprüfen möchten. Anstelle eines großen verschachtelten if-Statements mit zahlreichen Alternativblöcken können wir also die C# switch Blöcke nutzen, die unseren Code wesentlich schöner und übersichtlicher gestalten.