Arrays

Sie können mehrere Variablen des gleichen Typs in einer Arraydatenstruktur speichern. Ein Array wird deklariert, indem der Typ seiner Elemente angegeben wird. Wenn das Array Elemente eines beliebigen Typs speichern soll, geben Sie object als Typ an. Im vereinheitlichen Typsystem von C# erben alle Typen, vordefiniert und benutzerdefiniert sowie Verweis- und Werttypen, direkt oder indirekt von Object.

Die C#-Sprachreferenz dokumentiert die zuletzt veröffentlichte Version der C#-Sprache. Außerdem enthält sie erste Dokumentation für Features in der öffentlichen Vorschau für die kommende Sprachversion.

In der Dokumentation werden alle Features identifiziert, die in den letzten drei Versionen der Sprache oder in der aktuellen öffentlichen Vorschau eingeführt wurden.

Tipp

Informationen dazu, wann ein Feature erstmals in C# eingeführt wurde, finden Sie im Artikel zum Versionsverlauf der C#-Sprache.

type[] arrayName;

Bei einem Array handelt es sich um einen Verweistyp, so dass es sich bei dem Array um einen Verweistyp handeln kann, der Nullwerte zulässt. Die Elementtypen können Referenztypen sein, sodass Sie ein Array deklarieren können, das nullwerte Verweistypen enthält. Die folgenden Beispieldeklarationen zeigen die unterschiedliche Syntax, die zum Deklarieren der Nullierbarkeit des Arrays oder der Elemente verwendet wird:

type?[] arrayName; // non nullable array of nullable element types.
type[]? arrayName; // nullable array of non-nullable element types.
type?[]? arrayName; // nullable array of nullable element types.

Nicht initialisierte Elemente in einem Array werden auf den Standardwert für diesen Typ festgelegt:

int[] numbers = new int[10]; // All values are 0
string[] messages = new string[10]; // All values are null.

Wichtig

Im vorherigen Beispiel ist der Standardwert für jedes Element null, obwohl der Typ string[]ist - ein Array aus nicht-null-fähigen Zeichenfolgen. Die beste Möglichkeit, ein Array mit Nicht-Null-Werten zu initialisieren, ist die Verwendung von Sammlungsausdrücken.

Ein Array verfügt über die folgenden Eigenschaften:

• Ein Array kann eindimensional, mehrdimensional oder verzweigt sein.
• Die Anzahl der Dimensionen wird festgelegt, wenn Sie eine Arrayvariable deklarieren. Sie legen die Länge jeder Dimension fest, wenn Sie die Arrayinstanz erstellen. Sie können diese Werte während der Lebensdauer der Instanz nicht ändern.
• Ein Jagged Array ist ein Array von Arrays, und jedes Memberarray hat den Standardwert null.
• Arrays sind nullbasiert: Der Index eines Arrays mit n Elementen beginnt bei 0 und endet bei n-1.
• Arrayelemente können einen beliebigen Typ aufweisen, z. B. auch einen Arraytyp.
• Arraytypen sind Referenztypen, die vom abstrakten Basistyp Array abgeleitet werden. Alle Arrays implementieren IList und IEnumerable. Sie können die foreach-Anweisung verwenden, um ein Array zu durchlaufen. Eindimensionale Arrays implementieren ebenfalls IList<T> und IEnumerable<T>.

Sie können die Elemente eines Arrays auf bekannte Werte initialisieren, wenn Sie das Array erstellen. Ab C# 12 können Sie einen Sammlungsausdruck verwenden, um alle Auflistungstypen zu initialisieren. Elemente, die Sie nicht initialisieren, werden auf den Standardwert festgelegt. Der Standardwert ist das 0-Bit-Muster. Alle Verweistypen (einschließlich nicht nullabler Typen) weisen den Wert nullauf. Alle Werttypen weisen das 0-Bit-Muster auf. Das bedeutet, dass die Nullable<T>.HasValue-Eigenschaft false und die Nullable<T>.Value-Eigenschaft nicht definiert ist. In der .NET-Implementierung löst die Value-Eigenschaft eine Ausnahme aus.

In den folgenden Beispiel wird ein eindimensionales, ein mehrdimensionales und ein verzweigtes Array erstellt:

// Declare a single-dimensional array of 5 integers.
int[] array1 = new int[5];

// Declare and set array element values.
int[] array2 = [1, 2, 3, 4, 5, 6];

// Declare a two dimensional array.
int[,] multiDimensionalArray1 = new int[2, 3];

// Declare and set array element values.
int[,] multiDimensionalArray2 = { { 1, 2, 3 }, { 4, 5, 6 } };

// Declare a jagged array.
int[][] jaggedArray = new int[6][];

// Set the values of the first array in the jagged array structure.
jaggedArray[0] = [1, 2, 3, 4];

Wichtig

Viele Beispiele in diesem Artikel verwenden Auflistungsausdrücke (die eckige Klammern verwenden), um die Arrays zu initialisieren. Sammlungsausdrücke wurden erstmals in C# 12 eingeführt, das mit .NET 8 bereitgestellt wurden. Wenn Sie noch kein Upgrade auf C# 12 durchführen können, verwenden { Sie stattdessen die Arrays, und } initialisieren Sie sie.

// Collection expressions:
int[] array = [1, 2, 3, 4, 5, 6];
// Alternative syntax:
int[] array2 = {1, 2, 3, 4, 5, 6};

Eindimensionale Arrays

Ein eindimensionales Array ist eine Sequenz von ähnlichen Elementen. Sie greifen über den Index auf ein Element zu. Der Index ist die Ordnungsposition des Elements in der Sequenz. Das erste Element im Array hat den Index 0. Sie erstellen ein eindimensionales Array, indem Sie den neuen Operator verwenden und den Arrayelementtyp und die Anzahl der Elemente angeben. Im folgenden Beispiel wird ein eindimensionales Array deklariert und initialisiert:

int[] array = new int[5];
string[] weekDays = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];

Console.WriteLine(weekDays[0]);
Console.WriteLine(weekDays[1]);
Console.WriteLine(weekDays[2]);
Console.WriteLine(weekDays[3]);
Console.WriteLine(weekDays[4]);
Console.WriteLine(weekDays[5]);
Console.WriteLine(weekDays[6]);

/*Output:
Sun
Mon
Tue
Wed
Thu
Fri
Sat
*/

Die erste Deklaration deklariert ein nicht initialisiertes Array mit fünf Integern von array[0] bis array[4]. Die Elemente des Arrays werden mit dem Standardwert des Elementtyps initialisiert (0 für ganze Zahlen). Die zweite Deklaration deklariert ein Array von Zeichenfolgen und initialisiert alle sieben Werte dieses Arrays. Eine Reihe von Console.WriteLine-Anweisungen druckt alle Elemente des weekDay-Arrays. Bei eindimensionalen Arrays verarbeitet die Anweisung foreach Elemente in aufsteigender Indexreihenfolge, beginnend bei Index 0 bis hin zu Index Length - 1:

Weitere Informationen zu Indizes finden Sie im Artikel " Erkunden von Indizes und Bereichen" .

Übergeben von eindimensionalen Arrays als Argumente

Sie können ein initialisiertes eindimensionales Array an eine Methode übergeben. Im folgenden Beispiel wird ein Array von Zeichenfolgen initialisiert und als Argument an eine DisplayArray-Methode für Zeichenfolgen übergeben. Die Methode zeigt die Elemente des Arrays an. Als Nächstes kehrt die ChangeArray-Methode die Elemente des Arrays um, und die ChangeArrayElements-Methode ändert die ersten drei Elemente des Arrays. Nachdem jede Methode zurückgegeben wird, zeigt die DisplayArray-Methode an, dass das Übergeben eines Arrays nach Wert keine Änderungen an den Arrayelementen verhindert.

class ArrayExample
{
    static void DisplayArray(string[] arr) => Console.WriteLine(string.Join(" ", arr));

    // Change the array by reversing its elements.
    static void ChangeArray(string[] arr) => Array.Reverse(arr);

    static void ChangeArrayElements(string[] arr)
    {
        // Change the value of the first three array elements.
        arr[0] = "Mon";
        arr[1] = "Wed";
        arr[2] = "Fri";
    }

    static void Main()
    {
        // Declare and initialize an array.
        string[] weekDays = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
        // Display the array elements.
        DisplayArray(weekDays);
        Console.WriteLine();

        // Reverse the array.
        ChangeArray(weekDays);
        // Display the array again to verify that it stays reversed.
        Console.WriteLine("Array weekDays after the call to ChangeArray:");
        DisplayArray(weekDays);
        Console.WriteLine();

        // Assign new values to individual array elements.
        ChangeArrayElements(weekDays);
        // Display the array again to verify that it has changed.
        Console.WriteLine("Array weekDays after the call to ChangeArrayElements:");
        DisplayArray(weekDays);
    }
}
// The example displays the following output:
//         Sun Mon Tue Wed Thu Fri Sat
//
//        Array weekDays after the call to ChangeArray:
//        Sat Fri Thu Wed Tue Mon Sun
//
//        Array weekDays after the call to ChangeArrayElements:
//        Mon Wed Fri Wed Tue Mon Sun

Mehrdimensionale Arrays

Arrays können mehr als eine Dimension aufweisen. Die folgenden Deklarationen erstellen beispielsweise vier Arrays. Zwei Arrays weisen zwei Dimensionen auf. Zwei Arrays haben drei Dimensionen. Die ersten beiden Deklarationen deklarieren die Länge jeder Dimension, initialisieren jedoch nicht die Werte des Arrays. Die zweiten beiden Deklarationen verwenden einen Initialisierer, um die Werte der einzelnen Elemente im multidimensionalen Array festzulegen.

int[,] array2DDeclaration = new int[4, 2];

int[,,] array3DDeclaration = new int[4, 2, 3];

// Two-dimensional array.
int[,] array2DInitialization =  { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } };
// Three-dimensional array.
int[,,] array3D = new int[,,] { { { 1, 2, 3 }, { 4,   5,  6 } },
                                { { 7, 8, 9 }, { 10, 11, 12 } } };

// Accessing array elements.
System.Console.WriteLine(array2DInitialization[0, 0]);
System.Console.WriteLine(array2DInitialization[0, 1]);
System.Console.WriteLine(array2DInitialization[1, 0]);
System.Console.WriteLine(array2DInitialization[1, 1]);

System.Console.WriteLine(array2DInitialization[3, 0]);
System.Console.WriteLine(array2DInitialization[3, 1]);
// Output:
// 1
// 2
// 3
// 4
// 7
// 8

System.Console.WriteLine(array3D[1, 0, 1]);
System.Console.WriteLine(array3D[1, 1, 2]);
// Output:
// 8
// 12

// Getting the total count of elements or the length of a given dimension.
var allLength = array3D.Length;
var total = 1;
for (int i = 0; i < array3D.Rank; i++)
{
    total *= array3D.GetLength(i);
}
System.Console.WriteLine($"{allLength} equals {total}");
// Output:
// 12 equals 12

Bei mehrdimensionalen Arrays werden die Indizes der äußerst rechten Dimension zuerst erhöht, dann die nächste linke Dimension usw. bis zum äußerst linken Index. Im folgenden Beispiel werden sowohl ein 2D- als auch ein 3D-Array aufgelistet:

int[,] numbers2D = { { 9, 99 }, { 3, 33 }, { 5, 55 } };

foreach (int i in numbers2D)
{
    System.Console.Write($"{i} ");
}
// Output: 9 99 3 33 5 55

int[,,] array3D = new int[,,] { { { 1, 2, 3 }, { 4,   5,  6 } },
                        { { 7, 8, 9 }, { 10, 11, 12 } } };
foreach (int i in array3D)
{
    System.Console.Write($"{i} ");
}
// Output: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12

In einem 2D-Array können Sie sich den linken Index als Zeile und den rechten Index als Spalte vorstellen.

Bei mehrdimensionalen Arrays bietet ihnen die Verwendung einer geschachtelten For-Schleife jedoch mehr Kontrolle über die Reihenfolge, in der Sie die Arrayelemente verarbeiten:

int[,,] array3D = new int[,,] { { { 1, 2, 3 }, { 4,   5,  6 } },
                        { { 7, 8, 9 }, { 10, 11, 12 } } };

for (int i = 0; i < array3D.GetLength(0); i++)
{
    for (int j = 0; j < array3D.GetLength(1); j++)
    {
        for (int k = 0; k < array3D.GetLength(2); k++)
        {
            System.Console.Write($"{array3D[i, j, k]} ");
        }
        System.Console.WriteLine();
    }
    System.Console.WriteLine();
}
// Output (including blank lines):
// 1 2 3
// 4 5 6
//
// 7 8 9
// 10 11 12
//

Übergeben von mehrdimensionalen Arrays als Argumente

Übergeben Sie ein initialisiertes mehrdimensionales Array auf die gleiche Weise an eine Methode, wie Sie ein eindimensionales Array übergeben. Der folgende Code zeigt eine partielle Deklaration einer print-Methode, die ein zweidimensionales Array als Argument akzeptiert. Sie können ein neues Array in einem Schritt initialisieren und übergeben, wie im folgenden Beispiel gezeigt. Im folgenden Beispiel wird ein zweidimensionales Array von ganzen Zahlen initialisiert und an die Print2DArray-Methode übergeben. Die Methode zeigt die Elemente des Arrays an.

static void Print2DArray(int[,] arr)
{
    // Display the array elements.
    for (int i = 0; i < arr.GetLength(0); i++)
    {
        for (int j = 0; j < arr.GetLength(1); j++)
        {
            System.Console.WriteLine($"Element({i},{j})={arr[i,j]}");
        }
    }
}
static void ExampleUsage()
{
    // Pass the array as an argument.
    Print2DArray(new int[,] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } });
}
/* Output:
    Element(0,0)=1
    Element(0,1)=2
    Element(1,0)=3
    Element(1,1)=4
    Element(2,0)=5
    Element(2,1)=6
    Element(3,0)=7
    Element(3,1)=8
*/

Verzweigte Arrays

Ein Jagged Array ist ein Array, dessen Elemente Arrays möglicherweise verschiedener Größe sind. Ein verzweigtes Array wird auch „Array aus Arrays“ genannt. Die Elemente sind Verweistypen und werden mit null initialisiert. Die folgenden Beispiele zeigen, wie Sie verzweigte Arrays deklarieren, initialisieren und auf sie zugreifen können. Das erste Beispiel (jaggedArray) wird in einer Anweisung deklariert. Jedes enthaltene Array wird in nachfolgenden Anweisungen erstellt. Das zweite Beispiel (jaggedArray2) wird in einer Anweisung deklariert und initialisiert. Sie können gezackte und multidimensionale Arrays kombinieren. Das letzte Beispiel (jaggedArray3) zeigt die Deklaration und Initialisierung eines eindimensionalen Jagged Array, das drei zweidimensionale Arrayelemente unterschiedlicher Größe enthält.

int[][] jaggedArray = new int[3][];

jaggedArray[0] = [1, 3, 5, 7, 9];
jaggedArray[1] = [0, 2, 4, 6];
jaggedArray[2] = [11, 22];

int[][] jaggedArray2 =
[
    [1, 3, 5, 7, 9],
    [0, 2, 4, 6],
    [11, 22]
];

// Assign 77 to the second element ([1]) of the first array ([0]):
jaggedArray2[0][1] = 77;

// Assign 88 to the second element ([1]) of the third array ([2]):
jaggedArray2[2][1] = 88;

int[][,] jaggedArray3 =
[
    new int[,] { {1,3}, {5,7} },
    new int[,] { {0,2}, {4,6}, {8,10} },
    new int[,] { {11,22}, {99,88}, {0,9} }
];

Console.Write("{0}", jaggedArray3[0][1, 0]);
Console.WriteLine(jaggedArray3.Length);

Sie müssen die Elemente eines markierten Arrays initialisieren, bevor Sie sie verwenden können. Jedes Element ist selbst ein Array. Sie können auch Initialisierer verwenden, um die Arrayelemente mit Werten zu füllen. Wenn Sie Initialisierer verwenden, benötigen Sie die Arraygröße nicht.

In diesem Beispiel wird ein Array erstellt, dessen Elemente wiederum selbst Arrays sind. Jedes Arrayelement hat eine unterschiedliche Größe.

// Declare the array of two elements.
int[][] arr = new int[2][];

// Initialize the elements.
arr[0] = [1, 3, 5, 7, 9];
arr[1] = [2, 4, 6, 8];

// Display the array elements.
for (int i = 0; i < arr.Length; i++)
{
    System.Console.Write("Element({0}): ", i);

    for (int j = 0; j < arr[i].Length; j++)
    {
        System.Console.Write("{0}{1}", arr[i][j], j == (arr[i].Length - 1) ? "" : " ");
    }
    System.Console.WriteLine();
}
/* Output:
    Element(0): 1 3 5 7 9
    Element(1): 2 4 6 8
*/

Implizit typisierte Arrays

Sie können ein implizit typisiertes Array erstellen, in dem der Typ der Arrayinstanz von den im Arrayinitialisierer angegebenen Elementen abgeleitet wird. Die Regeln für implizit typisierte Variablen gelten auch für implizit typisierte Arrays. Weitere Informationen zu finden Sie unter Implizit typisierte lokale Variablen.

Die folgenden Beispiele zeigen, wie ein implizit typisiertes Array erstellt wird:

int[] a = new[] { 1, 10, 100, 1000 }; // int[]

// Accessing array
Console.WriteLine("First element: " + a[0]);
Console.WriteLine("Second element: " + a[1]);
Console.WriteLine("Third element: " + a[2]);
Console.WriteLine("Fourth element: " + a[3]);
/* Outputs
First element: 1
Second element: 10
Third element: 100
Fourth element: 1000
*/

var b = new[] { "hello", null, "world" }; // string[]

// Accessing elements of an array using 'string.Join' method
Console.WriteLine(string.Join(" ", b));
/* Output
hello  world
*/

// single-dimension jagged array
int[][] c =
[
    [1,2,3,4],
    [5,6,7,8]
];
// Looping through the outer array
for (int k = 0; k < c.Length; k++)
{
    // Looping through each inner array
    for (int j = 0; j < c[k].Length; j++)
    {
        // Accessing each element and printing it to the console
        Console.WriteLine($"Element at c[{k}][{j}] is: {c[k][j]}");
    }
}
/* Outputs
Element at c[0][0] is: 1
Element at c[0][1] is: 2
Element at c[0][2] is: 3
Element at c[0][3] is: 4
Element at c[1][0] is: 5
Element at c[1][1] is: 6
Element at c[1][2] is: 7
Element at c[1][3] is: 8
*/

// jagged array of strings
string[][] d =
[
    ["Luca", "Mads", "Luke", "Dinesh"],
    ["Karen", "Suma", "Frances"]
];

// Looping through the outer array
int i = 0;
foreach (var subArray in d)
{
    // Looping through each inner array
    int j = 0;
    foreach (var element in subArray)
    {
        // Accessing each element and printing it to the console
        Console.WriteLine($"Element at d[{i}][{j}] is: {element}");
        j++;
    }
    i++;
}
/* Outputs
Element at d[0][0] is: Luca
Element at d[0][1] is: Mads
Element at d[0][2] is: Luke
Element at d[0][3] is: Dinesh
Element at d[1][0] is: Karen
Element at d[1][1] is: Suma
Element at d[1][2] is: Frances
*/

Beachten Sie im vorherigen Beispiel, dass bei implizit typisierten Arrays auf der linken Seite der Initialisierungsanweisung keine eckigen Klammern verwendet werden. Jagged Arrays werden ebenso wie eindimensionale Arrays mithilfe von new [] initialisiert.

Beim Erstellen eines anonymen Typs, der ein Array enthält, muss das Array im Objektinitialisierer des Typs implizit typisiert werden. Im folgenden Beispiel ist contacts ein implizit typisiertes Array aus anonymen Typen, von denen jeder ein Array mit dem Namen PhoneNumbers enthält. Das Schlüsselwort var wird nicht in den Objektinitialisierern verwendet.

var contacts = new[]
{
    new
    {
        Name = "Eugene Zabokritski",
        PhoneNumbers = new[] { "206-555-0108", "425-555-0001" }
    },
    new
    {
        Name = "Hanying Feng",
        PhoneNumbers = new[] { "650-555-0199" }
    }
};