Inhaltsverzeichnis

1. Wiederholung: Was sind C# Attribute bzw. Eigenschaften?

Im vergangenen Artikel hast du gelernt, dass eine Eigenschaft im Grunde ein Konstrukt aus einer privaten Variable und zwei Methoden ist. Nämlich der Get- und der Set-Methode.

1.1. Die Get-Methode

Die Get-Methode verwenden wir, wie es der Name schon sagt, um den Wert zu „getten“, also diesen aus der privaten Variable zu lesen.

Mit der Get-Methode hat man also einen lesenden Zugriff auf die private Variable.

Inhaltsverzeichnis

1. Was sind C# Eigenschaften?

Auf den ersten Blick wirken C# Eigenschaften wie ganz normale Variablen einer Klasse und man verwendet sie auch ähnlich. Genau deshalb habe ich in den vergangenen Beiträgen geschrieben, man könne sie sich vorerst als solche vorstellen. In der Realität sind sie allerdings keine normalen Variablen.

C# Eigenschaften sind besondere Variablen, welche wir mithilfe von zwei Methoden beschreiben und lesen können. Dabei handelt es sich um die sogenannten get- und set-Methoden. Man verwendet Eigenschaften zum Kapseln von Daten. Was das bedeutet, werde ich dir später noch erklären.

Um es vorab schon mal einfach auszudrücken: Eigenschaften sind besondere Variablen, auf welche wir nicht direkt, sondern über zwei Methoden zugreifen.

Über die get-Methode lesen wir den Wert von Eigenschaften und

über die set-Methode überschreiben wir den Wert von Eigenschaften.

Inhaltsverzeichnis

1. Was ist ein Konstruktor?

Ein Konstruktor ist eine spezielle Methode, die immer beim Erstellen eines Objekts aufgerufen wird. Man nutzt ihn dazu, um das Objekt zu konstruieren, also um beispielsweise Eigenschafts- und Variablenwerte zu initialisieren oder andere Dinge zu veranlassen, die beim Erstellen eines Objekts geschehen sollen.

Der Konstruktor ist die erste Methode, die immer aufgerufen wird, wenn wir ein Objekt von einer Klasse erzeugen.

Dazu sehen wir uns nun ein Beispiel an. Auf der folgenden Abbildung kannst du eine Klasse sehen, die „Person“ heißt:

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.