Ausführbare C#-Docs: Arrays

Q: Wie bekomme ich in C# die Länge eines Arrays?

Mit der Property Length: scores.Length. Sie ist eine Property, keine Methode, also ohne Klammern. Bei einem 2D-Array ist Length die Gesamtzahl der Elemente; nimm GetLength(0) für die Anzahl der Zeilen und GetLength(1) für die Anzahl der Spalten.

Q: Wie sortiere ich in C# ein Array?

Array.Sort(arr) sortiert das Array an Ort und Stelle aufsteigend. Für absteigende Reihenfolge rufe nach dem Sortieren Array.Reverse(arr) auf oder übergib einen Vergleich: Array.Sort(arr, (a, b) => b.CompareTo(a)). Um eine sortierte Kopie zu bekommen und das Original zu behalten, nimm LINQ: arr.OrderBy(x => x).ToArray().

Q: Was ist der Unterschied zwischen einem 2D-Array und einem Jagged Array in C#?

Ein 2D-Array int[,] ist ein einziger rechteckiger Block: Jede Zeile hat dieselbe Anzahl Spalten, und du indizierst es als grid[row, col]. Ein Jagged Array int[][] ist ein Array von Arrays: Jede Zeile ist ein eigenes Array mit eigener Länge, und du indizierst es als rows[i][j]. Jede Zeile eines Jagged Arrays muss vor der Verwendung erzeugt werden, sonst ist sie null.

Q: Warum zeigt die Ausgabe eines Arrays System.Int32[]?

Console.WriteLine(arr) ruft arr.ToString() auf, und Arrays überschreiben das nicht, also bekommst du den Typnamen. Verbinde die Elemente stattdessen zu einem String: Console.WriteLine(string.Join(", ", arr)).

Ein Array enthält eine feste Anzahl von Elementen eines Typs, die im Speicher nebeneinander liegen. Du wählst die Länge beim Erzeugen, liest und schreibst Elemente über einen nullbasierten Index, und die Länge ändert sich danach nie.

Ein Array deklarieren und initialisieren

Der Typ eines Arrays ist der Elementtyp gefolgt von []. Es gibt mehrere Wege, eines zu erzeugen:

using System;

class Program
{
    static void Main()
    {
        int[] scores = new int[4];                     // 4 elements, all 0
        string[] names = { "Ana", "Ben", "Chloe" };     // initializer
        double[] prices = new double[] { 2.5, 9.99 };   // explicit form
        var days = new[] { "Mon", "Tue", "Wed" };       // type inferred: string[]

        scores[0] = 90;
        scores[3] = 72;

        Console.WriteLine(string.Join(", ", scores));
        Console.WriteLine(names[1]);
        Console.WriteLine(prices.Length + " prices, " + days.Length + " days");
    }
}

Ausgabe:

90, 0, 0, 72
Ben
2 prices, 3 days

new int[4] füllt jedes Element mit dem Standardwert des Typs: 0 für Zahlen, false für bool, null für Strings und andere Referenztypen. Die Kurzform { "Ana", "Ben" } funktioniert nur in einer Deklaration; bei der Zuweisung an eine bestehende Variable brauchst du names = new[] { "Dev", "Eli" };.

Length, Indizierung und das letzte Element

Indizes reichen von 0 bis Length - 1. Length ist eine Property, hat also keine Klammern (anders als die LINQ-Methode Count()).

using System;

class Program
{
    static void Main()
    {
        int[] temps = { 18, 21, 25, 19, 16 };

        Console.WriteLine("Count: " + temps.Length);
        Console.WriteLine("First: " + temps[0]);
        Console.WriteLine("Last: " + temps[temps.Length - 1]);

        try
        {
            Console.WriteLine(temps[5]);
        }
        catch (IndexOutOfRangeException e)
        {
            Console.WriteLine("Caught " + e.GetType().Name);
        }
    }
}

Ausgabe:

Count: 5
First: 18
Last: 16
Caught IndexOutOfRangeException

Lesen oder Schreiben außerhalb der Grenzen wirft zur Laufzeit IndexOutOfRangeException; der Compiler erkennt das nicht. Die übliche Ursache ist eine Schleifenbedingung i <= arr.Length statt i < arr.Length.

Ab C# 8 gibt es Indizes vom Ende und Bereichssyntax, die für das letzte Element und für Ausschnitte kürzer sind:

int last = temps[^1];        // 16
int[] middle = temps[1..4];  // { 21, 25, 19 }, a new array

Ein Array durchlaufen

Eine for-Schleife gibt dir den Index; foreach gibt dir jedes Element und ist die klarere Wahl, wenn du nur liest.

using System;

class Program
{
    static void Main()
    {
        decimal[] prices = { 4.50m, 12.00m, 3.25m };

        for (int i = 0; i < prices.Length; i++)
        {
            prices[i] = Math.Round(prices[i] * 1.10m, 2); // raise every price by 10%
        }

        decimal total = 0;
        foreach (decimal p in prices)
        {
            total += p;
        }

        Console.WriteLine(string.Join(" | ", prices));
        Console.WriteLine("Total: " + total);
    }
}

Ausgabe:

4.95 | 13.20 | 3.58
Total: 21.73

Die foreach-Variable ist schreibgeschützt: p = 0; in der Schleife ist ein Kompilierfehler. Um Elemente zu ändern, durchlaufe das Array mit einem Index.

Sortieren, umkehren und suchen

Die statische Klasse Array enthält die Hilfsmethoden. Array.Sort sortiert an Ort und Stelle und gibt nichts zurück, die ursprüngliche Reihenfolge ist also weg.

using System;

class Program
{
    static void Main()
    {
        int[] scores = { 72, 95, 60, 88, 79 };

        Array.Sort(scores);
        Console.WriteLine("Ascending:  " + string.Join(", ", scores));

        Array.Reverse(scores);
        Console.WriteLine("Descending: " + string.Join(", ", scores));

        Console.WriteLine("Index of 60: " + Array.IndexOf(scores, 60));
        Console.WriteLine("Index of 99: " + Array.IndexOf(scores, 99));
        Console.WriteLine("Any above 90: " + Array.Exists(scores, s => s > 90));
        Console.WriteLine("First below 75: " + Array.Find(scores, s => s < 75));

        string[] names = { "chloe", "Ana", "ben" };
        Array.Sort(names, StringComparer.OrdinalIgnoreCase);
        Console.WriteLine(string.Join(", ", names));

        string[] fruits = { "kiwi", "banana", "fig" };
        Array.Sort(fruits, (a, b) => a.Length.CompareTo(b.Length)); // by length
        Console.WriteLine(string.Join(", ", fruits));
    }
}

Ausgabe:

Ascending:  60, 72, 79, 88, 95
Descending: 95, 88, 79, 72, 60
Index of 60: 4
Index of 99: -1
Any above 90: True
First below 75: 72
Ana, ben, chloe
fig, kiwi, banana

Array.IndexOf gibt -1 zurück, wenn der Wert fehlt. Array.Find gibt den Standardwert des Typs zurück (hier 0), wenn nichts passt, was bei Zahlen mehrdeutig ist; nimm Array.FindIndex, wenn das wichtig ist. Eine absteigende Sortierung in einem Aufruf ist Array.Sort(scores, (a, b) => b.CompareTo(a)).

Wenn du das sortierte Ergebnis brauchst, ohne das Original anzufassen, gibt LINQ ein neues Array zurück: var sorted = scores.OrderBy(s => s).ToArray();. Siehe LINQ.

Größe ändern: Ein Array kann nicht wachsen

Die Länge ist fest. Array.Resize erzeugt ein neues Array der gewünschten Größe, kopiert die Elemente und aktualisiert die Variable, die du per ref übergibst.

using System;

class Program
{
    static void Main()
    {
        string[] queue = { "Ana", "Ben" };
        string[] before = queue;

        Array.Resize(ref queue, 4);
        queue[2] = "Chloe";

        Console.WriteLine(queue.Length);
        Console.WriteLine(before.Length);             // the old array is unchanged
        Console.WriteLine(queue[3] == null);          // new slots get the default
        Console.WriteLine(ReferenceEquals(before, queue));
    }
}

Ausgabe:

4
2
True
False

Jedes Resize kopiert jedes Element. Ein Array in einer Schleife Element für Element wachsen zu lassen ist langsam, und genau das erledigt List<T> effizienter für dich, indem es sein internes Array verdoppelt.

Arrays sind Referenztypen: kopieren

Ein Array einer anderen Variable zuzuweisen kopiert die Referenz, nicht die Elemente. Beide Namen zeigen dann auf dasselbe Array.

using System;

class Program
{
    static void Main()
    {
        int[] original = { 1, 2, 3 };

        int[] alias = original;
        alias[0] = 100;
        Console.WriteLine(original[0]); // 100: same array

        int[] copy = (int[])original.Clone();
        copy[1] = 200;
        Console.WriteLine(original[1]); // 2: independent array

        int[] target = new int[5];
        Array.Copy(original, 0, target, 1, 3); // source, start, dest, start, count
        Console.WriteLine(string.Join(", ", target));
    }
}

Ausgabe:

100
2
0, 100, 2, 3, 0

Dasselbe gilt, wenn du ein Array an eine Methode übergibst: Die Methode kann die Elemente des Aufrufers ändern. Clone, Array.Copy, CopyTo und ToArray() aus LINQ erzeugen alle eine flache Kopie. Bei einem Array von Objekten enthält das neue Array Referenzen auf dieselben Objekte, eine Änderung an copy[0].Name ändert also weiterhin, was original[0] sieht.

Arrays mit == zu vergleichen vergleicht Referenzen. Um Inhalte zu vergleichen, nimm a.SequenceEqual(b) aus System.Linq.

2D-Arrays (mehrdimensional)

Ein rechteckiges Raster wird mit einem Komma in den eckigen Klammern deklariert. Indiziere es mit [row, col].

using System;

class Program
{
    static void Main()
    {
        int[,] seats = new int[2, 3]; // 2 rows, 3 columns
        seats[0, 1] = 1;
        seats[1, 2] = 1;

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

        Console.WriteLine("Rows: " + grid.GetLength(0));
        Console.WriteLine("Cols: " + grid.GetLength(1));
        Console.WriteLine("Length: " + grid.Length + ", Rank: " + grid.Rank);

        for (int r = 0; r < seats.GetLength(0); r++)
        {
            for (int c = 0; c < seats.GetLength(1); c++)
            {
                Console.Write(seats[r, c] == 1 ? "X " : ". ");
            }
            Console.WriteLine();
        }
    }
}

Ausgabe:

Rows: 2
Cols: 3
Length: 6, Rank: 2
. X . 
. . X

Length ist bei einem 2D-Array die Gesamtzahl der Elemente (6 bei einem Raster von 2 mal 3), deshalb verwenden verschachtelte Schleifen GetLength(0) und GetLength(1). Rank ist die Anzahl der Dimensionen. Drei Dimensionen funktionieren genauso: new int[4, 4, 4] und cube[x, y, z]. Ein foreach über ein 2D-Array besucht jedes Element Zeile für Zeile.

Jagged Arrays (Arrays von Arrays)

Ein Jagged Array int[][] ist ein Array, dessen Elemente selbst Arrays sind, und jedes innere Array kann seine eigene Länge haben. Es passt zu Daten wie „Bestellungen pro Kunde“, bei denen sich die Zeilen in der Größe unterscheiden.

using System;

class Program
{
    static void Main()
    {
        int[][] orders = new int[3][]; // 3 rows, none created yet
        orders[0] = new[] { 20, 35 };
        orders[1] = new[] { 12 };
        orders[2] = new[] { 8, 15, 40, 22 };

        for (int i = 0; i < orders.Length; i++)
        {
            Console.WriteLine("Customer " + i + ": " + orders[i].Length
                + " orders, " + string.Join(", ", orders[i]));
        }

        int[][] empty = new int[2][];
        Console.WriteLine(empty[0] == null);
    }
}

Ausgabe:

Customer 0: 2 orders, 20, 35
Customer 1: 1 orders, 12
Customer 2: 4 orders, 8, 15, 40, 22
True

new int[3][] erzeugt nur das äußere Array; jede Zeile beginnt als null, und orders[0][0] vor der Zuweisung einer Zeile wirft NullReferenceException. Die Syntax new int[3][4] ist nicht erlaubt; du erzeugst jede Zeile selbst.

Nimm [,] für ein echtes Raster (ein Spielbrett, eine Matrix, Pixel) und [][], wenn Zeilen unterschiedlich lang sind oder du ganze Zeilen austauschen willst.

Array gegenüber List

	Array `T[]`	`List<T>`
Größe	Bei der Erzeugung festgelegt	Wächst und schrumpft
Anzahl	Property `Length`	Property `Count`
Hinzufügen oder entfernen	Nicht möglich (nur `Array.Resize`)	`Add`, `Insert`, `Remove`
Mehrdimensional	`[,]` und `[][]`	Nur Listen von Listen
Typischer Einsatz	Bekannte Größe, Nachschlagetabellen, Puffer	Collections, die sich ändern

Die Umwandlung ist in beide Richtungen ein Aufruf: new List<int>(arr) oder arr.ToList() und list.ToArray(). List<T> ist die wachsende Variante.

Häufige Fehler

i <= arr.Length in einer Schleife. Der letzte gültige Index ist Length - 1; das wirft IndexOutOfRangeException.
Das Array direkt ausgeben. Console.WriteLine(arr) gibt System.Int32[] aus; nimm string.Join.
Erwarten, dass Array.Sort das sortierte Array zurückgibt. Es gibt void zurück und sortiert an Ort und Stelle.
Mit = kopieren. Das kopiert die Referenz; nimm Clone() oder ToArray().
Zeilen eines Jagged Arrays verwenden, bevor sie erzeugt sind. Jede Zeile von new T[n][] ist null, bis sie zugewiesen wird.
Length für die Zeilen eines 2D-Arrays verwenden. Es zählt jedes Element; nimm GetLength(0).

Häufig gestellte Fragen

Wie bekomme ich in C# die Länge eines Arrays?

Mit der Property Length: scores.Length. Sie ist eine Property, keine Methode, also ohne Klammern. Bei einem 2D-Array ist Length die Gesamtzahl der Elemente; nimm GetLength(0) für die Anzahl der Zeilen und GetLength(1) für die Anzahl der Spalten.

Wie sortiere ich in C# ein Array?

Array.Sort(arr) sortiert das Array an Ort und Stelle aufsteigend. Für absteigende Reihenfolge rufe nach dem Sortieren Array.Reverse(arr) auf oder übergib einen Vergleich: Array.Sort(arr, (a, b) => b.CompareTo(a)). Um eine sortierte Kopie zu bekommen und das Original zu behalten, nimm LINQ: arr.OrderBy(x => x).ToArray().

Was ist der Unterschied zwischen einem 2D-Array und einem Jagged Array in C#?

Ein 2D-Array int[,] ist ein einziger rechteckiger Block: Jede Zeile hat dieselbe Anzahl Spalten, und du indizierst es als grid[row, col]. Ein Jagged Array int[][] ist ein Array von Arrays: Jede Zeile ist ein eigenes Array mit eigener Länge, und du indizierst es als rows[i][j]. Jede Zeile eines Jagged Arrays muss vor der Verwendung erzeugt werden, sonst ist sie null.

Kann man in C# die Größe eines Arrays ändern?

Nein. Die Länge eines Arrays steht bei seiner Erzeugung fest. Array.Resize(ref arr, newSize) sieht aus, als würde es die Größe ändern, allokiert aber ein neues Array, kopiert die Elemente und lässt deine Variable auf das neue zeigen. Wenn sich die Größe oft ändert, nimm eine List<T>.

Warum zeigt die Ausgabe eines Arrays System.Int32[]?

Console.WriteLine(arr) ruft arr.ToString() auf, und Arrays überschreiben das nicht, also bekommst du den Typnamen. Verbinde die Elemente stattdessen zu einem String: Console.WriteLine(string.Join(", ", arr)).

Soll ich in C# ein Array oder eine List verwenden?

Nimm ein Array, wenn die Anzahl der Elemente bekannt und fest ist, etwa die 12 Monate oder ein Spielbrett. Nimm List<T>, wenn im Lauf der Zeit Elemente hinzukommen oder wegfallen. Beide indizieren in konstanter Zeit, und eine List<T> speichert ihre Elemente intern in einem Array.

Verwandte Konzepte