C# Language
Array

Sintassi

• Dichiarazione di un array:

  <tipo> [] <nome>;

• Dichiarazione di array bidimensionale:

  <tipo> [,] <nome> = nuovo <tipo> [<valore>, <valore>];

• Dichiarazione di una matrice seghettata:

  <tipo> [] <nome> = nuovo <tipo> [<valore>];

• Dichiarazione di un sottoarray per una matrice frastagliata:

  <nome> [<valore>] = nuovo <tipo> [<valore>];

• Inizializzazione di un array senza valori:

  <nome> = nuovo <tipo> [<lunghezza>];

• Inizializzazione di un array con valori:

  <nome> = nuovo <tipo> [] {<valore>, <valore>, <valore>, ...};

• Inizializzazione di un array bidimensionale con valori:

  <nome> = nuovo <tipo> [,] {{valore>, <valore>}, {<valore>, <valore>}, ...};

• Accedere a un elemento all'indice i:

  <Nome> [i]

• Ottenere la lunghezza dell'array:

  <Nome> .Length

Osservazioni

Covarianza di matrice

string[] strings = new[] {"foo", "bar"};
object[] objects = strings; // implicit conversion from string[] to object[]

Questa conversione non è sicura dal testo. Il seguente codice genererà un'eccezione di runtime:

string[] strings = new[] {"Foo"};
object[] objects = strings;

objects[0] = new object(); // runtime exception, object is not string
string str = strings[0];   // would have been bad if above assignment had succeeded

Ottenere e impostare i valori dell'array

int[] arr = new int[] { 0, 10, 20, 30}; 

// Get 
Console.WriteLine(arr[2]); // 20

// Set 
arr[2] = 100;

// Get the updated value
Console.WriteLine(arr[2]); // 100

Dichiarare un array

Un array può essere dichiarato e riempito con il valore predefinito usando la sintassi di inizializzazione parentesi quadra ( [] ). Ad esempio, creando un array di 10 numeri interi:

int[] arr = new int[10];

Gli indici in C # sono a base zero. Gli indici dell'array sopra saranno 0-9. Per esempio:

int[] arr = new int[3] {7,9,4};
Console.WriteLine(arr[0]); //outputs 7
Console.WriteLine(arr[1]); //outputs 9

Il che significa che il sistema inizia a contare l'indice degli elementi da 0. Inoltre, gli accessi agli elementi degli array vengono eseguiti in un tempo costante . Ciò significa che l'accesso al primo elemento dell'array ha lo stesso costo (nel tempo) dell'accesso al secondo elemento, al terzo elemento e così via.

Si può anche dichiarare un riferimento nudo a un array senza istanziare un array.

int[] arr = null;   // OK, declares a null reference to an array.
int first = arr[0]; // Throws System.NullReferenceException because there is no actual array.

Un array può anche essere creato e inizializzato con valori personalizzati utilizzando la sintassi di inizializzazione della raccolta:

int[] arr = new int[] { 24, 2, 13, 47, 45 };

La new int[] porzione new int[] può essere omessa quando si dichiara una variabile di array. Questa non è un'espressione autonoma, quindi utilizzarla come parte di una chiamata diversa non funziona (per questo, usa la versione con una new ):

int[] arr = { 24, 2, 13, 47, 45 };  // OK
int[] arr1;
arr1 = { 24, 2, 13, 47, 45 };       // Won't compile

Array implicitamente tipizzati

In alternativa, in combinazione con la parola chiave var , il tipo specifico può essere omesso in modo da inferire il tipo della matrice:

// same as int[]
var arr = new [] { 1, 2, 3 };
// same as string[]
var arr = new [] { "one", "two", "three" };
// same as double[]
var arr = new [] { 1.0, 2.0, 3.0 };

Scorrere su un array

int[] arr = new int[] {1, 6, 3, 3, 9};

for (int i = 0; i < arr.Length; i++) 
{
    Console.WriteLine(arr[i]);
}

utilizzando foreach:

foreach (int element in arr) 
{
    Console.WriteLine(element);
}

utilizzando l'accesso non sicuro con i puntatori https://msdn.microsoft.com/en-ca/library/y31yhkeb.aspx

unsafe
{
    int length = arr.Length;
    fixed (int* p = arr)
    {
        int* pInt = p;
        while (length-- > 0)
        {
            Console.WriteLine(*pInt);
            pInt++;// move pointer to next element
        }
    }
}

Produzione:

1
6
3
3
9

Matrici multidimensionali

Le matrici possono avere più di una dimensione. Nell'esempio seguente viene creato un array bidimensionale di dieci righe e dieci colonne:

int[,] arr = new int[10, 10];

Un array di tre dimensioni:

int[,,] arr = new int[10, 10, 10];

È anche possibile inizializzare la matrice sulla dichiarazione:

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

// Access a member of the multi-dimensional array:
Console.Out.WriteLine(arr[3, 1]);  // 4

Matrici frastagliate

Gli array frastagliati sono array che invece di tipi primitivi contengono array (o altre raccolte). È come un array di array: ogni elemento dell'array contiene un altro array.

Sono simili agli array multidimensionali, ma presentano una leggera differenza: poiché gli array multidimensionali sono limitati a un numero fisso di righe e colonne, con matrici frastagliate, ogni riga può avere un numero diverso di colonne.

Dichiarare una matrice seghettata

Ad esempio, dichiarando una matrice frastagliata con 8 colonne:

int[][] a = new int[8][];

Il secondo [] viene inizializzato senza un numero. Per inizializzare i sottoarray, è necessario farlo separatamente:

for (int i = 0; i < a.length; i++) 
{
    a[i] = new int[10];
}

Ottenimento / impostazione dei valori

Ora, ottenere uno dei sottotitoli è facile. Stampiamo tutti i numeri della 3a colonna di a :

for (int i = 0; i < a[2].length; i++)
{
    Console.WriteLine(a[2][i]);
}

Ottenere un valore specifico:

a[<row_number>][<column_number>]

Impostazione di un valore specifico:

a[<row_number>][<column_number>] = <value>

Ricorda : è sempre consigliabile utilizzare matrici frastagliate (matrici di matrici) piuttosto che array multidimensionali (matrici). È più veloce e più sicuro da usare.

Nota sull'ordine delle parentesi

Considera una matrice tridimensionale di matrici a cinque dimensioni di matrici unidimensionali di int . Questo è scritto in C # come:

int[,,][,,,,][] arr = new int[8, 10, 12][,,,,][];

Nel sistema tipo CLR, la convenzione per l'ordinamento delle staffe è invertita, quindi con quanto sopra arr esempio abbiamo:

    arr.GetType().ToString() == "System.Int32[][,,,,][,,]"

e allo stesso modo:

    typeof(int[,,][,,,,][]).ToString() == "System.Int32[][,,,,][,,]"

Verifica se un array contiene un altro array

public static class ArrayHelpers
{
    public static bool Contains<T>(this T[] array, T[] candidate)
    {
        if (IsEmptyLocate(array, candidate))
            return false;

        if (candidate.Length > array.Length)
            return false;

        for (int a = 0; a <= array.Length - candidate.Length; a++)
        {
            if (array[a].Equals(candidate[0]))
            {
                int i = 0;
                for (; i < candidate.Length; i++)
                {
                    if (false == array[a + i].Equals(candidate[i]))
                        break;
                }
                if (i == candidate.Length)
                    return true;
            }
        }
        return false;
    }

    static bool IsEmptyLocate<T>(T[] array, T[] candidate)
    {
        return array == null
            || candidate == null
            || array.Length == 0
            || candidate.Length == 0
            || candidate.Length > array.Length;
    }
}

/// Campione

byte[] EndOfStream = Encoding.ASCII.GetBytes("---3141592---");
byte[] FakeReceivedFromStream = Encoding.ASCII.GetBytes("Hello, world!!!---3141592---");
if (FakeReceivedFromStream.Contains(EndOfStream))
{
    Console.WriteLine("Message received");
}

Inizializzazione di un array riempito con un valore non predefinito ripetuto

Come sappiamo, possiamo dichiarare un array con valori predefiniti:

int[] arr = new int[10];

Questo creerà una matrice di 10 numeri interi con ogni elemento dell'array che ha valore 0 (il valore predefinito di tipo int ).

Per creare un array inizializzato con un valore non predefinito, è possibile utilizzare Enumerable.Repeat dallo System.Linq nomi System.Linq :

1. Per creare un array bool di dimensioni 10 pieno di "true"

   bool[] booleanArray = Enumerable.Repeat(true, 10).ToArray(); 
   

2. Per creare un array int di dimensione 5 riempito con "100"

   int[] intArray = Enumerable.Repeat(100, 5).ToArray();
   

3. Per creare una serie di string di dimensione 5 riempita con "C #"

   string[] strArray = Enumerable.Repeat("C#", 5).ToArray();
   

Copia di array

Copia di una matrice parziale con il metodo statico Array.Copy() , a partire dall'indice 0 in entrambi, origine e destinazione:

var sourceArray = new int[] { 11, 12, 3, 5, 2, 9, 28, 17 };
var destinationArray= new int[3];
Array.Copy(sourceArray, destinationArray, 3);

// destinationArray will have 11,12 and 3

Copia l'intero array con il metodo di istanza CopyTo() , iniziando dall'indice 0 dell'origine e dall'indice specificato nella destinazione:

var sourceArray = new int[] { 11, 12, 7 };
var destinationArray = new int[6];
sourceArray.CopyTo(destinationArray, 2);

// destinationArray will have 0, 0, 11, 12, 7 and 0

Clone è usato per creare una copia di un oggetto array.

var sourceArray = new int[] { 11, 12, 7 };
var destinationArray = (int)sourceArray.Clone();

//destinationArray will be created and will have 11,12,17.

Sia CopyTo che Clone eseguono una copia superficiale che significa che il contenuto contiene riferimenti allo stesso oggetto degli elementi nell'array originale.

Creare una serie di numeri sequenziali

LINQ fornisce un metodo che semplifica la creazione di una raccolta piena di numeri sequenziali. Ad esempio, è possibile dichiarare una matrice che contiene gli interi tra 1 e 100.

Il metodo Enumerable.Range ci consente di creare una sequenza di numeri interi da una posizione iniziale specificata e un numero di elementi.

Il metodo accetta due argomenti: il valore iniziale e il numero di elementi da generare.

Enumerable.Range(int start, int count)

Si noti che il count non può essere negativo.

Uso:

int[] sequence = Enumerable.Range(1, 100).ToArray();

Questo genererà un array contenente i numeri da 1 a 100 ( [1, 2, 3, ..., 98, 99, 100] ).

Poiché il metodo Range restituisce un oggetto IEnumerable<int> , possiamo utilizzare altri metodi LINQ su di esso:

int[] squares = Enumerable.Range(2, 10).Select(x => x * x).ToArray();

Questo genererà una matrice che contiene 10 numeri interi a partire da 4 : [4, 9, 16, ..., 100, 121] .

Confronto tra array per l'uguaglianza

LINQ fornisce una funzione integrata per il controllo dell'uguaglianza di due IEnumerable , e tale funzione può essere utilizzata sugli array.

La funzione SequenceEqual restituirà true se gli array hanno la stessa lunghezza ei valori negli indici corrispondenti sono uguali e false altrimenti.

int[] arr1 = { 3, 5, 7 };
int[] arr2 = { 3, 5, 7 };
bool result = arr1.SequenceEqual(arr2);
Console.WriteLine("Arrays equal? {0}", result);

Questo stamperà:

Arrays equal? True

Array come istanze IEnumerable <>

Tutti gli array implementano l'interfaccia IList non generica (e quindi le interfacce di base ICollection e IEnumerable non generiche).

Ancora più importante, gli array unidimensionali implementano le interfacce generiche IList<> e IReadOnlyList<> (e le loro interfacce di base) per il tipo di dati che contengono. Ciò significa che possono essere trattati come tipi enumerabili generici e inoltrati a una varietà di metodi senza dover prima convertirli in un modulo non array.

int[] arr1 = { 3, 5, 7 };
IEnumerable<int> enumerableIntegers = arr1; //Allowed because arrays implement IEnumerable<T>
List<int> listOfIntegers = new List<int>();
listOfIntegers.AddRange(arr1); //You can pass in a reference to an array to populate a List.

Dopo aver eseguito questo codice, la lista listOfIntegers conterrà una List<int> contenente i valori 3, 5 e 7.

Il supporto IEnumerable<> significa che gli array possono essere interrogati con LINQ, ad esempio arr1.Select(i => 10 * i) .