So definieren Sie ein Array in C#

1. Eine Dimension:
int[] Zahlen = neues int[]{1,2,3,4,5,6} //Unbestimmte Länge
int[] Zahlen = neues int[3 ]{1,2,3};//Feste Länge
Zwei mehrdimensionale
int[,] Zahlen = new int[,]{{1,2,3},{1,2,3 }} ; //Variable Länge
int[,] zahlen = new int[2,2]{{1,2},{1,2}} //Feste Länge

3
A: int[] mf1=new int[6];
//Achten Sie auf den Bereich des initialisierten Arrays oder geben Sie den Anfangswert an; //Eindimensionales Ganzzahlarray mit 6 Elementen, Anfangswerten ​​1, 2, 3, 4, 5, 6
int[] mf2=new int[6]{1,2,3,4,5,6}

B：// Eindimensionales String-Array, falls angegeben. Wenn der Initialisierer angegeben ist, können Sie den neuen Operator
string[] mf3={"c","c++","c#"}; : //Eindimensionales Objektarray
Object[] mf4 = new Object[5] { 26, 27, 28, 29, 30 }; // Zweidimensionales Ganzzahlarray, initial Wert mf5[0,0]=1 ,mf5[0,1]=2,mf5[1,0]=3,mf5[1,1]=4
int[,] mf5=new int[,] {{1,2},{3 ,4}};

E: //6*6 zweidimensionales Ganzzahlarray
int[,] mf6=new mf[6,6]; 🎜>
4. Erhalten Sie die Anzahl der Array-Elemente:
int b;
b = sizeof (a)/sizeof (*a);



C#-String- und Array-Operation
2007-12-12 17:53String-Operation (die aktuelle Zeit abrufen)

string time=convert.tostring(DateTime.Today).split( new char []{' ' }); textbox1.text =time[0]; Leerzeichen als Abgrenzungspunkte verwenden;

Array-Übersicht

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, während sie in der C-Sprache Teil des Array-Typs ist. Auf diese Weise können Sie ein Array deklarieren und ihm unabhängig von der Array-Länge ein beliebiges Array von int-Objekten zuweisen.
int[] zahlen; // Zahlen als int-Array beliebiger Größe deklarieren
numbers = new int[10] // zahlen ist ein 10-Elemente-Array

numbers = new int[20]; // jetzt ist es ein Array mit 20 Elementen

Deklarationsarray
C# unterstützt eindimensionale Arrays, mehrdimensionale Arrays (rechteckige Arrays) und Arrays von Arrays (verschachtelte Arrays). Das folgende Beispiel zeigt, wie Arrays verschiedener Typen deklariert werden:
Eindimensionales Array: int[] Zahlen;
Mehrdimensionales Array: string[,] Namen
Array von Arrays (verschachtelt): Byte [][ ] Scores;
Durch die Deklaration von Arrays (siehe oben) werden diese nicht tatsächlich erstellt. In C# sind Arrays Objekte (wird später in diesem Tutorial besprochen) und müssen instanziiert werden. Das folgende Beispiel zeigt, wie man ein Array erstellt:
Eindimensionales Array: int[] Zahlen = neues int[5];

Mehrdimensionales Array: string[,] Namen = neuer String[5,4] ;

Array Array of (interleaved): byte[][] scores = new byte[5][] for (int x = 0; x < scores.Length; x++) {scores[x] = new byt [4];
}
Sie können auch größere Arrays haben. Sie können beispielsweise ein dreidimensionales rechteckiges Array 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, ein zweidimensionales Array vom Typ int und ein dreidimensionales Array vom Typ int[][,,][,] Zahlen;

Initialisieren Sie ein Array
C# durch Einschließen des Anfangswerts Das Einschließen von geschweiften Klammern ({}) bietet eine einfache und unkomplizierte Möglichkeit, ein Array zum Zeitpunkt der Deklaration zu initialisieren. 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.

Eindimensionales Array
int[] Zahlen = neuer int[5] {1, 2, 3, 4, 5};
string[] Namen = neuer String[3] {" Matt ", "Joanne", "Robert"};

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

int[] zahlen = new int[] {1, 2, 3, 4, 5} ;
string[] Namen = neuer String[] {"Matt", "Joanne", "Robert"};
Wenn ein Initialisierer bereitgestellt wird, kann der neue Operator auch weggelassen werden, wie folgt:

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

string[] Namen = {"Matt", "Joanne", "Robert"};

Mehrdimensionales Array
int[,] Zahlen = new int[3, 2] { {1, 2}, {3, 4}, {5, 6} };
string[,] Geschwister = neuer String[2, 2] { {"Mike","Amy"}, {"Mary","Albert"} };
Die Größe des Arrays kann wie folgt weggelassen werden:
int[, ] Zahlen = neue int[,] { {1, 2}, {3, 4}, {5, 6} };
string[,] Geschwister = neue Zeichenfolge[,] { {"Mike","Amy "} , {"Mary","Albert"} };
Wenn ein Initialisierer bereitgestellt wird, kann der neue Operator wie folgt auch weggelassen werden:
int[,] zahlen = { {1, 2 }, {3, 4}, {5, 6} };
string[,] siblings = { {"Mike", "Amy"}, {"Mary", "Albert"} };

Gezacktes Array (Array von Arrays)
Sie können ein gezacktes Array wie im folgenden Beispiel gezeigt initialisieren:
int[][] zahlen = 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[][] zahlen = new int [] [] { new int[] {2,3,4}, new int[] {5,6,7,8,9} };-or-
int[][] zahlen = { new int [] {2,3,4}, new int[] {5,6,7,8,9} };
Bitte beachten Sie, dass es keine Initialisierungssyntax für Elemente eines gezackten Arrays gibt.

Zugriff auf Array-Mitglieder
Der Zugriff auf Array-Mitglieder kann direkt erfolgen, ähnlich wie der Zugriff auf Array-Mitglieder in C/C++. Der folgende Code erstellt beispielsweise ein Array mit dem Namen „Zahlen“ und weist dem fünften Element des Arrays 5 zu:
int[] Zahlen = {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[,] zahlen = { {1, 2}, {3, 4}, {5, 6}, {7, 8}, {9, 10} };
Zahlen[1, 1] = 5;
unten Deklarieren Sie eine Eins -dimensionales gezacktes 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[][] zahlen = new int[][] { new int[] {1, 2}, new int [] {3, 4, 5}};
Die folgende Anweisung weist dem ersten Element des ersten Arrays 58 und dem zweiten Element des zweiten Arrays 667 zu:
Zahlen [0][0] = 58 ;
Zahlen[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 (5) einer Variablen namens „LengthOfNumbers“ zu:
int[] zahlen = {1, 2, 3, 4, 5};
int LängeOfNumbers = zahlen.Länge ;
Die System.Array-Klasse bietet viele nützliche zusätzliche Methoden/Eigenschaften wie Methoden zum Sortieren, Suchen und Kopieren von Arrays.

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. Der folgende Code erstellt beispielsweise ein Array mit dem Namen „Zahlen“ und durchläuft das Array mithilfe einer foreach-Anweisung:
int[] zahlen = {4, 5, 6, 1, 2, 3, -2, -1, 0} ;
foreach (int i in zahlen){System.Console.WriteLine(i);}
Dank mehrdimensionaler Arrays können Sie dieselbe Methode verwenden, um über Elemente zu iterieren, zum Beispiel:
int [,] Zahlen = new int[3, 2] {{9, 99}, {3, 33}, {5, 55}};
foreach(int i in zahlen){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 zum Definieren von Arrays in C# finden Sie auf der chinesischen PHP-Website!