Tutorial di base C#

Tutorial avanzato C#

C# Orientato agli oggetti (OOP)

Array multidimensionale C#

C# supporta array multidimensionali con fino a 32 dimensioni. I array multidimensionali possono essere dichiarati aggiungendo virgole tra le parentesi quadre. Ad esempio, [ ] dichiara un array bidimensionale, [ , ] dichiara un array tridimensionale, [ , , ] dichiara un array tetradimensionale, ecc. Quindi, nel array multidimensionale, il numero di virgole = il numero di dimensioni - 1.

Dichiarazione di array multidimensionale

Esempio: array multidimensionale

int[, 2] arr2d; // array bidimensionale
int[, ,] arr3d; // array tridimensionale
int[, , ,] arr4d ; // array tetradimensionale
int[, , , ,] arr5d; // array quindicimensionale

Array bidimensionale

Lasciate che vi spieghiamo l'array bidimensionale. Di seguito viene inizializzato un array bidimensionale.

Esempio: array bidimensionale

int[, 2] arr2d = new int[3, 2]{　
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　{1, 2},　
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　{3, 4},　
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　{5, 6}　
　　　　　　　　　　　　　　　　　　　　　　　　　　　　;
// o　
int[, 2] arr2d = {　
　　　　　　　　　　　　　　　　　　　　{1, 2},　
　　　　　　　　　　　　　　　　　　　　{3, 4},　
　　　　　　　　　　　　　　　　　　　　{5, 6}　
　　　　　　　　　　　　　　　　;

Nell'esempio di array bidimensionale sopra, [3, 2] definisce il numero di righe e colonne. La prima colonna rappresenta il numero di righe, la seconda colonna definisce il numero di colonne. La seguente immagine dimostra l'array bidimensionale diviso in righe e colonne.

Array bidimensionale

Seguono i valori di accesso dell'array bidimensionale.

Esempio: accesso array bidimensionale

int[, 2] arr2d = new int[3, 2]{　
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　{1, 2},　
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　{3, 4},　
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　{5, 6}　
　　　　　　　　　　　　　　　　　　　　　　　　　　　　;
arr2d[0, 0]; // restituisce 1
arr2d[0, 1]; // restituisce 2
arr2d[1, 0]; // restituisce 3
arr2d[1, 1]; // restituisce 4
arr2d[2, 0]; // restituisce 5
arr2d[2, 1]; // restituisce 6
//arr2d[3, 0]; // lanciare un errore in tempo di esecuzione, perché non c'è la quarta riga

Negli esempi precedenti, i valori degli array bidimensionali possono essere accesi tramite gli indici di riga e di colonna [indice riga, indice colonna]. Pertanto, [0, 0] restituisce il valore della prima riga e della prima colonna [1, 1], e restituisce il valore della seconda riga e della seconda colonna.

Array tridimensionale

Ora, scopriamo l'array tridimensionale. Di seguito è riportata la dichiarazione e l'inizializzazione dell'array tridimensionale.

Esempio: array tridimensionale

int[, ,] arr3d1 = new int[1, , 2]{
　　　　　　　　　　　　　　　　{ { 1, 2}, { 3, 4} }
　　　　　　　　　　　　;
int[, ,] arr3d2 = new int[2, , 2]{
　　　　　　　　　　　　　　　　{ {1, 2}, {3, 4} },
　　　　　　　　　　　　　　　　{ {5, 6}, {7, 8} }
　　　　　　　　　　　　;
int[, ,] arr3d3 = new int[2, , 3]{
　　　　　　　　　　　　　　　　{ { 1, 2, 3}, {4, 5, 6} }
　　　　　　　　　　　　　　　　{ { 7, 8, 9}, {10, 11, 12} }
　　　　　　　　　　　　;
arr3d2[0, 0, 0]; // restituisce 1　
arr3d2[0, 0, 1]; // restituisce 2　
arr3d2[0, 1, 0]; // restituisce 3　
arr3d2[0, 1, 1]; // restituisce 4　
arr3d2[1, 0, 0]; // restituisce 5　
arr3d2[1, 0, 1]; // restituisce 6　
arr3d2[1, 1, 0]; // restituisce 7　
arr3d2[1, 1, 1]; // restituisce 8

Come puoi vedere nell'esempio sopra, arr3d1[1,2,2] specifica che conterrà una riga dell'array bidimensionale [2,2]. arr3d2 specifica le dimensioni [2,2,2], che rappresenta due righe dell'array bidimensionale [2,2]. Pertanto, la prima colonna rappresenta il numero di righe dell'array bidimensionale interno.

Array quadrimensionale

Ora, guardiamo l'array quadrimensionale seguente.

Esempio: array quadrimensionale

int[,,,] arr4d1 = new int[1, 1, 2, 2]{
　　　　　　　　　　　　　　　　{　
　　　　　　　　　　　　　　　　　　　　{ { 1, 2}, { 3, 4} }　　　　　
　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　;
arr4d1[0, 0, 0, 0]; // restituisce 1
arr4d1[0, 0, 0, 1]; // restituisce 2
arr4d1[0, 0, 1, 0]; // restituisce 3
arr4d1[0, 0, 1, 1]; // restituisce 4
int[,,,] arr4d2 = new int[1, 2, 2, 2]{
		{
			{ {1, 2}, {3, 4} },
			{ {5, 6}, {7, 8} }
		}
	;
arr4d2[0, 0, 0, 0]; // restituisce 1
arr4d2[0, 0, 0, 1]; // restituisce 2
arr4d2[0, 0, 1, 0]; // restituisce 3
arr4d2[0, 0, 1, 1]; // Restituisce 4
arr4d2[0, 1, 0, 0]; // Restituisce 5
arr4d2[0, 1, 0, 1]; // Restituisce 6
arr4d2[0, 1, 1, 0]; // Restituisce 7
arr4d2[0, 1, 1, 1]; // Restituisce 8

Nell'esempio sopra, l'array a quattro dimensioni arr4d1 è specificato come [1, 1, 2, 2], il che significa che contiene una riga di array a tre dimensioni.

Nello stesso modo, è possibile dichiarare e inizializzare array a 5, 6 e fino a 32 dimensioni in C#.

FileInfo di C#Array di C#