Alles über das C# Array (mit Codebeispielen)

Mit mehreren Werten eines Datentyps zu arbeiten, gehört in der Programmierung zum Alltag. Eine Möglichkeit diese zu organisieren, die in fast jeder Programmiersprache existiert, ist das Array. Wie man das C# Array verwenden kann, kannst du hier nachlesen.

Ein C# Array deklarieren

Um ein einfaches Array zu erstellen, hast du mehrere Möglichkeiten. Du kannst zum einen Arrays einfach erstellen, indem du den Datentyp, den jedes Element haben soll, angibst und die Anzahl der Elemente.

int[] array = new int[3];

Alternativ kannst du gleich ein Array mit Werten erstellen.

int[] array = {1, 2, 3};

Du kannst auch beides kombinieren.

int[] array = new int[3] {1, 2, 3};

Auf die Werte eines Arrays zugreifen

Auf die einzelnen Werte eines Arrays kannst du über deren Index zugreifen. Der Index basiert auf 0. Das heißt, du kannst auf das erste Element mit 0 zugreifen, auf das Zweite mit 1, auf das Dritte mit 2, usw.

string[] array = {"code", "citrus"};
Console.WriteLine(array[1]);
// citrus

So kannst du auch mit einer for-Schleife auf jedes einzelne Element zugreifen.

int[] array = {1, 2, 3};
for (int i=0; i < array.Length; i++) {
    Console.WriteLine(array[i]);
}

int[] array = {1, 2, 3};
for (int i=0; i < array.Length; i++) {
    Console.WriteLine(array[i]);
}

Du kannst dafür auch foreach verwenden.

int[] array = {1, 2, 3};
foreach (int wert in array) {
    Console.WriteLine(wert);
}

1
2
3

C# Array als Parameter an Methoden übergeben

Du kannst Arrays auch als Parameter an Methoden übergeben. Die folgende Methode multipliziert das erste Element eines Arrays mit dem Zweiten und gibt das Ergebnis zurück.

static int ElementeMultiplizieren(int[] array) {
    return array[0] * array[1];
}

Verwenden kannst du diese Methode dann wie folgt:

int[] array = {2, 3};
Console.WriteLine(ElementeMultiplizieren(array));
// 6

Mehrdimensionale Arrays

Ein Array ist mehrdimensional, wenn seine Werte selbst Arrays sind. Außerdem sind die im Array enthaltenen Arrays gleich groß.

int[,] array = new int[2, 3];

Alternativ kannst du auch hier gleich Werte für die Arrays angeben.

int[,] array = {{1, 2, 3}, {4, 5, 6}};

Die vorigen Beispiele zeigen die Erstellung von zweidimensionalen Arrays. Auf die gleiche Art und Weise kannst du auch Arrays mit mehreren Dimensionen erstellen.

int[,,,] arr = new int[1, 2, 4, 8];
int[,,] array = {{{1, 2}, {3, 4}}, {{5, 6}, {7, 8}}};

Länge von mehrdimensionalen C# Arrays ermitteln

Mit der Methode GetLength kannst du die Länge der einzelnen Dimensionen der Arrays ermitteln. Zur Demonstration der Methode verwende ich das vierdimensionale Array aus dem vorigen Beispiel.

Console.WriteLine(arr.GetLength(0));
// 1
Console.WriteLine(arr.GetLength(1));
// 2
Console.WriteLine(arr.GetLength(2));
// 4
Console.WriteLine(arr.GetLength(3));
// 8

Auf die Werte eines mehrdimensionalen Arrays zugreifen

Um auf die einzelnen Elemente des Arrays zuzugreifen, kannst du zuerst den Index des inneren Arrays angeben und dann den Index des Elements.

int[,] array = {{1, 2}, {3, 4}};
Console.WriteLine(array[1, 0]);
// 3

Auch hier kannst du mit foreach auf jedes Element einzeln zugreifen.

int[,] array = {{1, 2}, {3, 4}};
Console.WriteLine(array[1, 0]);
foreach (int wert in array) {
    Console.WriteLine(wert);
}

1
2
3
4

Um das Gleiche mit einer for-Schleife zu erzielen, kannst du eine Schleife in einer Schleife erstellen und mit GetLength die Bedingung festlegen.

int[,] array = {{1, 2, 3}, {4, 5, 6}};
for ({"type":"block","srcIndex":33,"srcClientId":"4b4e3b38-7894-4ba5-ad34-c90e3678e783","srcRootClientId":""}int i = 0; i < array.GetLength(0); i++) {
    for (int r = 0; r < array.GetLength(1); r++) {
        Console.WriteLine(array[i, r]);
    }
}

1
2
3
4
5
6

Verzweigte „Jagged“ Arrays

Ein Array ist ein verzweigtes (jagged) Array, wenn seine Werte selbst Arrays sind. Im Gegensatz zu mehrdimensionalen Arrays können die enthaltenen Arrays verschieden groß sein. Erstellen kannst du ein verzweigtes Array so:

int[][] array = new int[2][];

Die einzelnen enthaltenen Arrays kannst du erstellen, indem du einfach den Index, an dem es eingefügt werden soll, angibst und das neue Array zuweist.

int[][] array = new int[2][];
array[0] = new int[4] {1, 2, 3, 4};
array[1] = new int[3] {3, 2, 1};

Auf die Werte eines Jagged Arrays zugreifen

Auf die einzelnen Elemente kannst du wieder über deren Index zugreifen.

Console.WriteLine(array[1][0]);
// 3

Da die Elemente des Arrays wiederum Arrays sind, kannst du auch auf jedes dieser wieder mit foreach zugreifen.

foreach (int wert in array[0]) {
    Console.WriteLine(wert);
}

1
2
3
4

Die wohl einfachste Möglichkeit, auf jedes Element der Arrays zuzugreifen, ist die Verwendung von verschachtelten foreach-Schleifen.

foreach (int[] inneres_array in array) {
    foreach (int i in inneres_array) {
        Console.WriteLine(i);
    }
}

1
2
3
4
3
2
1

Fazit – Das C# Array

Die verschiedenen Typen von Arrays und deren Handhabung in C# sind nicht unbedingt einfach zu verstehen. Die Möglichkeiten dieser sind jedoch vielfältig und hier wurde nur ein Bruchteil davon abgedeckt. Einfache Arrays enthalten mehrere Werte eines Datentyps. Mehrdimensionale Arrays enthalten selbst Arrays, die alle die gleiche Größe haben. Verzweigte Arrays enthalten mehrere Arrays mit verschiedenen Größen. Die Handhabung all dieser ist zwar recht ähnlich, jedoch unterschiedlich genug, um bei Sprachanfängern für Verwirrung zu sorgen.

Wenn du Anmerkungen, Lob, Kritik oder Fragen hast, teile es mir bitte in einem Kommentar mit.