Da wir in der Regel nicht wissen können, wie viele Elemente in einem Array untergebracht sind, brauchen wie Vorgehensweisen, wie wir an alle Elemente eines Array gelangen können. Dafür können wir Schleifen nutzen, in diesem Unterkapitel werden wir uns insbesondere mit der foreach- und der for-Schleife beschäftigen.

Eindimensionales Array - foreach

C# stellt uns eine Schleife zur Verfügung, die foreach, also "für jeden", genannt wird. Mit Hilfe dieser Schleife können wir jedes Element eines Arrays "abklappern", ohne dass wir wissen müssen, an welcher Stelle dieses steht.

Nutzen wir das Beispiel aus dem vorherigen Unterkapitel:

string[] wochenTage = { "Mo", "Die", "Mi", "Do", "Fr", "Sa", "So" };.

Mit der foreach-Schleife können wir jetzt jeden Wochentag aus dem Array auslesen und zum Beispiel ausgeben lassen:

1
2
3
4
foreach (string wochenTag in wochenTage)
{
    Console.WriteLine(wochenTag);
}

Im Schleifenkopf können wir erkennen, dass die Schleife über unsere Liste iterieren soll (in wochenTage) und dabei jedes dieser Elemente in eine neue Variable string wochenTag packen soll. Im Schleifenkörper können wir dann mit einem Console.WriteLine(wochenTag); den jeweiligen Wochentag ausgeben.
Wenn wir es sprachlich ausformulieren wollen, dann müssten wir sagen: "Für das erste Element, welches du in wochenTage findest, weise das Element der Variablen wochenTag zu und gib es anschließend aus. Danach nimm das nächste Element und beginn von vorn."

einfaches zweidimensionales Array - foreach

Die foreach-Schleife können wir auch bei einfachen zweidimensionalen Arrays nutzen. Dazu nutzen wir die Wetterdaten aus dem vorhergehenden Kapitel:

Also:

1
2
3
4
5
6
double[,] wetterDaten= {
                        { 9, 10.5, 1.018},
                        {12, 15.8, 1.023},
                        {15, 18.1, 1.022},
                        {18, 14.3, 1.020}
                       };

Geben wir jetzt die Daten mit einer foreach-Schleife aus, erhalten wir folgende Ausgabe:

Die Schleife geht jetzt das Array Zeile für Zeile durch und gibt uns jedes Element der Zeile nacheinander aus. Mit diesen Werten können wir fast garnichts (oder nur umständlich etwas) anfangen. Hintergrund ist der: wir müssten jetzt im foreach die Ausgaben mitzählen, und für jede erste (von drei) Ausgabe schreiben, dass es sich um die Zeit handelt. Für jede zweite (von drei) Ausgabe müssten wir schreiben, dass es sich um eine Temperatur handelt und für jede dritte Ausgabe, dass es sich um den Luftdruck handelt. Eine foreach-Schleife macht hier also wenig Sinn. Im Folgenden sehen wir uns an, wie es mit einem kleinen Trick doch funktioniert.

verschachteltes zweidimensionales Array - foreach

Wir haben gesehen, dass eine foreach-Schleife das Mantra "für jeden" sehr genau nimmt. Die Schleife orentiert sich nicht an Zeilen, sondern an Elementen. Sie geht also in die erste Zeile, arbeitet dort alle Spalten ab; geht danach in die zweite Zeile, arbeitetet dort alle Spalten ab; und so weiter. Dieses Vorgehen können wir uns zu nutze machen, indem wir unsere Tabelle etwas ander aufbauen. Wir legen sie nicht als Tabelle sondern als Liste von einer Liste ab.

Unsere Tabelle wetterDaten wandeln wir jetzt in eine Liste wetterDatenGut um, in der also jede Zeile nur ein Element enthält. Dieses Element ist dann aber auch wieder eine Liste, nämlich aus unseren wirklichen Wetterdaten.

1
2
3
4
5
6
double[][] wetterDatenGut = {
                         new double[]{ 9, 10.5, 1.018},
                         new double[]{12, 15.8, 1.023},
                         new double[]{15, 18.1, 1.022},
                         new double[]{18, 14.3, 1.020}
                        };

Unsere Daten sind jetzt also nicht mit in einer Tabelle, sondern in einer Liste bestehend aus Zeilen, wobei jede einzelne Zeile wiederum Spalten besitzt:

Mit einem foreach über die Liste wetterDatenGut erhalten wir jetzt wiederum eine Liste, die unseren Daten Uhrzeit, Temperatur und Luftdruck entsprechen:

1
2
3
4
foreach (double[] wetterDatum in wetterDatenGut)
{
    Console.WriteLine("Um " + wetterDatum[0] + " war es " + wetterDatum[1] + "°C warm, dabei betrug der Luftdruck " + wetterDatum[2] + " bar");
}

zweidimensionales Array - for

Wir können prinzipiell aber auch mit einem unverschachtelten Array arbeiten. Dabei müssen wir dann aber eine normale for-Schleife nutzen und entprechend selber Zählen.

1
2
3
4
5
6
double[,] wetterDaten= {
                        { 9, 10.5, 1.018},
                        {12, 15.8, 1.023},
                        {15, 18.1, 1.022},
                        {18, 14.3, 1.020}
                       };

Um jetzt über jede Zeile zu iterieren, müssen wir ersteinmal herausfinden, wie viele Zeile es überhaupt in unserem Array gibt:
int zahlZeilen = wetterDaten.GetLength(0);
Mit Hilfe dieser Information können wir jetzt eine for-Schleife laufen lassen, die über den Zeilenindex z auf jede Zeile zugreifen kann:

• wetterDaten[z, 0] für die Uhrzeit
• wetterDaten[z, 1] für die Temperatur
• wetterDaten[z, 2] für den Luftdruck

Wir müssen dabei darauf achten, dass GetLength(0) uns die Anzahl der Zeilen zurückgibt. Dementsprechend müssen wir dann dir Schleife von 0 bis zahlZeilen-1 laufen lassen.

GetLength(0) gitb uns die Anzahl der zur Verfügung stehenden Zeilen wieder, wollen wir die Anzahl der Spalten ermitteln, können wir das mit Hilfe von GetLength(1).

1
2
3
4
5
6
int zahlZeilen = wetterDaten.GetLength(0);

for (int z = 0; z <= zahlZeilen - 1; z++)
{
    Console.WriteLine("Um " + wetterDaten[z, 0] + " war es " + wetterDaten[z, 1] + "°C warm, dabei betrug der Luftdruck " + wetterDaten[z, 2] + " bar");
}

Projektdateien