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 Sie möchten, dass das Array Element jedes Typs speichert, können Sie object als dessen Typ angeben. Im vereinheitlichen Typsystem von C# erben alle Typen, vordefiniert und benutzerdefiniert sowie Verweis- und Werttypen, direkt oder indirekt von Object.

type[] arrayName;

Ein Array verfügt über die folgenden Eigenschaften:

• Ein Array kann eindimensional, mehrdimensional oder verzweigt sein.
• Die Anzahl der Dimensionen wird festgelegt, wenn eine Arrayvariable deklariert wird. Die Länge der einzelnen Dimensionen wird festgelegt, wenn die Arrayinstanz erstellt wird. Diese Werte können während der Lebensdauer der Instanz nicht geändert werden.
• 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>.

Die Elemente eines Arrays können bei der Erstellung des Arrays auf bekannte Werte initialisiert werden. Ab C# 12 können alle Sammlungstypen mithilfe eines Sammlungsausdrucks initialisiert werden. Elemente, die nicht initialisiert werden, werden auf den Standardwert festgelegt. Der Standardwert ist das 0-Bit-Muster. Alle Verweistypen (einschließlich der Non-Nullable-Typen) weisen den Wert null auf. 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];

// 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 seine Ordnungsposition in der Sequenz. Das erste Element im Array hat den Index 0. Sie erstellen ein eindimensionales Array mit dem Operator new, indem Sie 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:

Ü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 haben zwei Dimensionen, zwei 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 Elemente so durchlaufen, dass die Indizes der äußersten rechten Dimension zuerst erhöht werden, dann die der links daneben liegenden Dimension und so weiter, bis der Index ganz links erreicht ist. 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 haben Sie jedoch eine größere Kontrolle über die Reihenfolge bei der Verarbeitung von Arrayelementen, wenn Sie eine geschachtelte for-Schleife verwenden.

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

Sie können ein initialisiertes mehrdimensionales Array genauso wie Sie ein eindimensionales Array an eine Methode übergeben. Der folgende Code zeigt eine partielle Deklaration einer print-Methode, die ein zweidimensionales Array als Argument akzeptiert. Sie können einen neuen 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({0},{1})={2}", 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. Es ist möglich, Jagged Arrays und mehrdimensionale Arrays zu mischen. 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);

Die Jagged Array-Elemente müssen initialisiert werden, damit sie verwendet werden können. Jedes Element ist selbst ein Array. Es ist auch möglich, Initialisierer zum Ausfüllen der Arrayelemente mit Werten zu verwenden. 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" }
    }
};