Lies in den Artikel rein und unten bekommst Du ein unschlagbares Angebot!
Arrays gibt es wohl in jeder Programmiersprache, jeweils mit eigenen Besonderheiten. Wie füllt man ein Arrays? Wie greift man auf die Werte eines Arrays zu? Wie organisiert man mehrdimensionale Arrays? Wie durchläuft man die Werte eines Arrays oder ermittelt die Anzahl der enthaltenen Elemente? All diese Fragen beantwortet der vorliegende Artikel.
Unter VBA konnten Arrays nur einfache Werttypen aufnehmen, also beispielsweise Zahlen oder Zeichenketten. Wenn Sie etwa Objekte in einer Liste speichern wollten, mussten Sie auf eine Alternative wie das Collection– oder das Dictionary-Objekt zugreifen.
Unter C# können Sie dies gleichermaßen mit einem Array erledigen. Dies ist jedoch nicht der einzige Unterschied. In den folgenden Abschnitten erhalten Sie die Grundlagen für die Programmierung von Arrays mit C#.
Deklaration von Arrays
Unter VBA haben Sie ein Array durch das Hinzufügen eines Klammernpaares bei der Deklaration kenntlich gemacht:
Dim Zahlwoerter() As String
Wenn Sie schon wussten, wie viele Elemente das Array enthalten sollte, haben Sie diese Anzahl in Klammern angegeben:
Dim Zahlwoerter(9) As String
Dies bedeutete ohne weitere Angaben, dass das Array zehn Elemente mit den Indizes 0 bis 9 aufnehmen konnte.
Unter C# verwenden Sie keine runden, sondern eckige Klammern, und diese geben Sie auch nicht hinter dem Variablennamen, sondern hinter dem Datentyp an:
string[] Zahlwoerter;
Nun ist natürlich noch nicht bekannt, wie viele Elemente das Array aufnehmen soll. Dies geben Sie auch nicht bekannt, indem Sie die Anzahl einfach in die eckigen Klammern schreiben. Vielmehr ist eine Initialisierung unter Angabe der Anzahl der Elemente nötig. Diese können Sie in einer neuen Zeile erledigen:
Zahlwoerter = new string;
Oder Sie verwenden einfach einen Einzeiler zur gleichzeitigen Deklaration und Initialisierung:
string[] Zahlwoerter = new string;
Die Verwendung des Schlüsselworts new stellt hier im Gegensatz zum Vorgehen unter VBA heraus, dass es sich bei dem Array um ein Objekt handelt.
Stellt sich gleich die erste Frage: Besitzt das Array nun zehn Elemente? Und die zweite gleich hinterher: Wie werden diese indiziert – beginnend mit 0 oder 1?
Das Array enthält nun tatsächlich genau die angegebene Elementanzahl. Im Gegensatz zu der etwas unübersichtlichen Vorgehensweise von VBA, bei der die Anzahl von der Basis des Index abhängt, initialisiert C# genau mit der angegebenen Menge von Elementen.
Der Index basiert unter C# auf dem Wert 0. Auf ein Element greifen Sie über die Angabe des Indexwertes in eckigen Klammern zu, also etwa über Zahlwoerter[0] – mehr dazu weiter unten.
Array füllen
Schauen wir uns erstmal eine einfache Methode an, das Array zu füllen – und zwar direkt bei der Initialisierung. Ausgehend vom obigen Einzeiler gelingt dies so (in einer Zeile):
string[] Zahlwoerter = new String { "Eins", "Zwei", "Drei", "Vier", "Fünf", "Sechs", "Sieben", "Acht", "Neun", "Zehn" };
Sie geben also einfach die gewünschten Werte in einer geschweiften Klammer und durch Kommata getrennt an.
In diesem Fall soll das Array zehn Elemente aufnehmen und jedes der Elemente wird auch gleich gefüllt.
Es gibt noch eine Alternative, bei der Sie die Anzahl der Elemente nicht angeben und diese direkt aus der Anzahl der übergebenen Elemente ermittelt wird. In diesem Fall lassen Sie einfach die Angabe der Anzahl innerhalb der eckigen Klammern weg (in einer Zeile):
string[] Zahlwoerter = new String[] { "Eins", "Zwei", "Drei", "Vier", "Fünf", "Sechs", "Sieben", "Acht", "Neun", "Zehn" };
Anschließend geben wir die im Array gespeicherten Werte in der Konsole aus. Für den Zugriff auf den Inhalt eines der Elemente geben Sie den Variablennamen gefolgt vom gewünschten Index in eckigen Klammern an.
Am einfachsten bekommen wir den Inhalt eines Elements so auf die Konsole:
Console.WriteLine(Zahlen[0]);
Wir wollen aber gleich alle zehn, und dann auch noch mit einem kleinen Hinweistext:
Console.WriteLine("Wert von Zahlwoerter[0]: {0}", Zahlen[0]);
Console.WriteLine("Wert von Zahlwoerter: {0}", Zahlen);
Console.WriteLine("Wert von Zahlwoerter: {0}", Zahlen);
...
Console.WriteLine("Wert von Zahlwoerter: {0}", Zahlen);
Das Ergebnis sieht nun wie folgt aus:
Wert von Zahlwoerter[0]: Eins Wert von Zahlwoerter: Zwei Wert von Zahlwoerter: Drei ... Wert von Zahlwoerter: Zehn
Wichtig: Wenn Sie die Anzahl der zu erstellenden Elemente angeben und gleich dahinter die Elemente hinzufügen, muss deren Anzahl übereinstimmen.
Die schnellste Alternative, um ein Array direkt mit Werten zu füllen, lässt noch ein paar Schlüsselwörter weg und übergibt die Werte direkt als Array an die Variable:
string[] Zahlwoerter = { "Eins", "Zwei", "Drei", "Vier", "Fünf", "Sechs", "Sieben", "Acht", "Neun", "Zehn" };
Elemente nach Initialisierung füllen
Wenn Sie das Array zunächst deklarieren und initialisieren, aber noch nicht füllen, holen Sie dies in späteren Anweisungen nach.
Dazu weisen Sie einfach dem entsprechenden Element, das Sie über die Angabe des Indexwertes in eckigen Klammern referenzieren, den gewünschten Wert zu:
string[] Zahlwoerter = new string; Zahlwoerter[0] = "Eins"; Zahlwoerter = "Zwei"; Zahlwoerter = "Drei";
Wenn Sie nun alle Elemente ausgeben, bleiben die hinteren sieben leer. Die Elemente werden bei der Initialisierung gleich mit leeren Zeichenketten gefüllt.
0 als initialer Wert von Zahlen-Arrays
Probieren wir dies gleich noch mit Zahlen aus, um zu prüfen, mit welchem Wert das Element eines Zahlen-Arrays initial gefüllt wird:
int[] Zahlen = new int;
Zahlen[0] = 1;
Zahlen = 2;
Zahlen = 3;
Console.WriteLine("Wert von Zahlen[0]: {0}", Zahlen[0]);
Console.WriteLine("Wert von Zahlen: {0}", Zahlen);
Console.WriteLine("Wert von Zahlen: {0}", Zahlen);
Console.WriteLine("Wert von Zahlen: {0}", Zahlen);
Console.WriteLine("Wert von Zahlen: {0}", Zahlen);
Wir definieren also ein Array mit fünf int-Elementen und füllen dann nur drei davon. Das Ergebnis bei der Ausgabe aller Elemente inklusive der übrigen zwei sieht so aus:
Wert von Zahlen[0]: 1 Wert von Zahlen: 2 Wert von Zahlen: 3 Wert von Zahlen: 0 Wert von Zahlen: 0
Leere Zahlenelemente werden also direkt mit dem Wert 0 gefüllt.
Größe einer Dimension eines Array ermitteln
Unter VBA ermitteln Sie die Größe eines Arrays über die Differenz der Funktionen UBound und LBound mit dem Array als Parameter:
Debug.Print UBound(intZahlen()) - LBound(intZahlen())
Für mehrdimensionale Arrays gibt es noch weitere Besonderheiten. Unter C# gibt es verschiedene Eigenschaften, mit denen Sie die Anzahl der Elemente einer Dimension sowie die Gesamtzahl der Elemente ermitteln können. Zunächst reicht uns die Anzahl der Elemente einer einzigen Dimension. Die erhalten Sie mit der Funktion GetLength: