Arrays in C#

Array-Übersicht
Ein Array ist eine Datenstruktur, die mehrere Variablen desselben Typs enthält. Arrays werden mithilfe von Typen deklariert:
Arrays haben die folgenden Eigenschaften:

Arrays können eindimensional, mehrdimensional oder verschachtelt sein.

Numerische Array-Elemente haben ihren Standardwert auf Null gesetzt, während Referenzelemente ihren Standardwert auf Null gesetzt haben.

Ein Jagged-Array ist ein Array von Arrays, daher sind seine Elemente Referenztypen, die mit Null initialisiert werden.

Arrays werden von Null an indiziert: Ein Array mit n Elementen wird von 0 bis n-1 indiziert.

Array-Elemente können von jedem Typ sein, einschließlich Array-Typen.

Array-Typen sind Referenztypen, die vom abstrakten Basistyp Array abgeleitet sind. Da dieser Typ IEnumerable und IEnumerable implementiert, können Sie foreach-Iteration für alle Arrays in C# verwenden.

C#-Arrays werden bei Null indiziert, d. h. der Array-Index beginnt bei Null. Arrays funktionieren in C# ähnlich wie in den meisten anderen gängigen Sprachen. Es gibt jedoch einige Unterschiede, die beachtet werden sollten.
Bei der Deklaration eines Arrays müssen eckige Klammern ([]) auf den Typ und nicht auf den Bezeichner folgen. In C# ist es eine illegale Syntax, eckige Klammern nach einem Bezeichner zu setzen.

int[] table; // not int table[];

Ein weiteres Detail ist, dass die Größe eines Arrays nicht Teil seines Typs ist. Sie können ein Array deklarieren und ihm ein beliebiges Array von int-Objekten zuweisen, unabhängig von der Array-Länge.

int[] numbers; // declare numbers as an int array of any size
numbers = new int[10];  // numbers is a 10-element array
numbers = new int[20];  // now it's a 20-element array

Arrays deklarieren
C# unterstützt eindimensionale Arrays, mehrdimensionale Arrays (rechteckige Arrays) und Arrays von Arrays (verschachtelte Arrays). Das folgende Beispiel zeigt, wie verschiedene Arten von Arrays deklariert werden:
Eindimensionales Array:

int[] numbers;

Mehrdimensionales Array:

string[,] names;

Array von Arrays (verschachtelt):

byte[][] scores;

Durch die Deklaration von Arrays (siehe oben) werden diese nicht tatsächlich erstellt.

In C# sind Arrays Objekte und müssen instanziiert werden. Das folgende Beispiel zeigt, wie ein Array erstellt wird:
Eindimensionales Array:

int[] numbers = new int[5];

Mehrdimensionales Array:

string[,] names = new string[5,4];

Array von Arrays (verschachtelt):

byte[][] scores = new byte[5][];
for (int x = 0; x < scores.Length; x++) 
{
   scores[x] = new byte[4];
}

Auch große Arrays sind möglich. Sie können beispielsweise dreidimensionale rechteckige Arrays haben:

int[,,] buttons = new int[4,5,3];

Sie können sogar rechteckige Arrays und gezackte Arrays mischen. Der folgende Code deklariert beispielsweise ein eindimensionales Array aus einem zweidimensionalen Array vom Typ int und einem dreidimensionalen Array vom Typ.

int[][,,][,] numbers;

Das Initialisieren eines Arrays
bietet eine einfache und unkomplizierte Möglichkeit, ein Array zum Zeitpunkt der Deklaration zu initialisieren, indem der Anfangswert in geschweifte Klammern ({}) eingeschlossen wird. Die folgenden Beispiele zeigen verschiedene Möglichkeiten, Arrays unterschiedlicher Typen zu initialisieren.
Hinweis: Wenn das Array bei der Deklaration nicht initialisiert wird, werden die Array-Mitglieder automatisch auf den Standardanfangswert des Array-Typs initialisiert. Wenn ein Array außerdem als Feld eines Typs deklariert ist, wird es bei der Instanziierung des Typs auf den Standardwert Null gesetzt.
Eindimensionale Arrays

int[] numbers = new int[5] {1, 2, 3, 4, 5};
string[] names = new string[3] {"Matt", "Joanne", "Robert"};

Die Größe des Arrays kann wie folgt weggelassen werden:

int[] numbers = new int[] {1, 2, 3, 4, 5};
string[] names = new string[] {"Matt", "Joanne", "Robert"};

Wenn ein Initialisierer bereitgestellt wird, kann der neue Operator auch weggelassen werden , wie unten gezeigt:

int[] numbers = {1, 2, 3, 4, 5};
string[] names = {"Matt", "Joanne", "Robert"};

Mehrdimensionales Array

int[,] numbers = new int[3, 2] { {1, 2}, {3, 4}, {5, 6} };
string[,] siblings = new string[2, 2] { {"Mike","Amy"}, {"Mary","Albert"} };

Die Größe des Arrays kann weggelassen werden, wie unten gezeigt:

int[,] numbers = new int[,] { {1, 2}, {3, 4}, {5, 6} };
string[,] siblings = new string[,] { {"Mike","Amy"}, {"Mary","Albert"} };

If Wird ein Anfangswert bereitgestellt, können Sie den neuen Operator auch weglassen, wie unten gezeigt:

int[,] numbers = { {1, 2}, {3, 4}, {5, 6} };
string[,] siblings = { {"Mike", "Amy"}, {"Mary", "Albert"} };

Interleaved Array (Array von Arrays)
Sie können ein interleaved Array wie im folgenden Beispiel gezeigt initialisieren:

int[][] numbers = new int[2][] { new int[] {2,3,4}, new int[] {5,6,7,8,9} };

Die Größe des ersten Arrays kann wie folgt weggelassen werden:

int[][] numbers = new int[][] { new int[] {2,3,4}, new int[] {5,6,7,8,9} };

- oder -

int[][] numbers = { new int[] {2,3,4}, new int[] {5,6,7,8,9} };

Beachten Sie, dass keine Initialisierung von erfolgt die Elemente einer Jagged-Array-Grammatik.

Zugriff auf Array-Mitglieder
Der Zugriff auf Array-Mitglieder kann direkt erfolgen. Der folgende Code erstellt beispielsweise ein Array mit dem Namen „Numbers“ und weist dann 5 dem fünften Element des Arrays zu. :

int[] numbers = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
numbers[4] = 5;

Der folgende Code deklariert ein mehrdimensionales Array und weist dem Mitglied an [1, 1] den Wert 5 zu:

int[,] numbers = { {1, 2}, {3, 4}, {5, 6}, {7, 8}, {9, 10} };
numbers[1, 1] = 5;

Der folgende Code deklariert ein eindimensionales gezacktes Array Array, das zwei Elemente enthält. Das erste Element ist ein Array aus zwei Ganzzahlen und das zweite Element ist ein Array aus drei Ganzzahlen:

int[][] numbers = new int[][] { new int[] {1, 2}, new int[] {3, 4, 5}};

Die folgende Anweisung weist dem ersten Element des ersten Arrays 58 und dem ersten 58 zu Element des ersten Arrays. Dem zweiten Element der beiden Arrays wird 667 zugewiesen:

numbers[0][0] = 58;
numbers[1][1] = 667;

Arrays sind Objekte. In C# sind Arrays eigentlich Objekte. System.Array ist der abstrakte Basistyp für alle Array-Typen. Sie können die Eigenschaften von System.Array sowie andere Klassenmitglieder verwenden. Ein Beispiel für diese Verwendung ist die Verwendung der Eigenschaft „Länge“, um die Länge eines Arrays abzurufen. Der folgende Code weist die Länge des Zahlenarrays (die 5 beträgt) einer Variablen namens „LengthOfNumbers“ zu:

int[] numbers = {1, 2, 3, 4, 5};
int LengthOfNumbers = numbers.Length;

Die System.Array-Klasse bietet viele nützliche andere Methoden/Eigenschaften, beispielsweise zum Sortieren, Suchen und Kopieren Array-Methoden.

Verwenden Sie foreach für Arrays
C# stellt auch die foreach-Anweisung bereit. Diese Anweisung bietet eine einfache und klare Möglichkeit, die Elemente eines Arrays zu durchlaufen.
Zum Beispiel erstellt der folgende Code ein Array mit dem Namen „numbers“ und iteriert über das Array mithilfe einer foreach-Anweisung:

int[] numbers = {4, 5, 6, 1, 2, 3, -2, -1, 0};
foreach (int i in numbers)
{
   System.Console.WriteLine(i);
}

Dank mehrdimensionaler Arrays können Sie dieselbe Methode verwenden, um über die Elemente zu iterieren. zum Beispiel:

int[,] numbers = new int[3, 2] {{9, 99}, {3, 33}, {5, 55}};
foreach(int i in numbers)
{
   Console.Write("{0} ", i);
}

Die Ausgabe dieses Beispiels ist:

9 99 3 33 5 55

Dank mehrdimensionaler Arrays erhalten Sie jedoch durch die Verwendung verschachtelter for-Schleifen eine bessere Kontrolle über die Array-Elemente.

Weitere Artikel zu Arrays in C# finden Sie auf der chinesischen PHP-Website!