MatriciArrays

Una matrice è una struttura di dati che contiene un numero di variabili a cui si accede tramite indici calcolati.An array is a data structure that contains a number of variables which are accessed through computed indices. Le variabili contenute in una matrice, chiamate anche elementi della matrice, sono tutte dello stesso tipo, definito tipo di elemento della matrice.The variables contained in an array, also called the elements of the array, are all of the same type, and this type is called the element type of the array.

Una matrice ha un rango che determina il numero di indici associati a ogni elemento della matrice.An array has a rank which determines the number of indices associated with each array element. Il rango di una matrice viene anche definito dimensioni della matrice.The rank of an array is also referred to as the dimensions of the array. Una matrice con un rango di uno è denominata *matrice unidimensionale _.An array with a rank of one is called a *single-dimensional array _. Una matrice con un rango maggiore di uno è detta matrice multidimensionale* *.An array with a rank greater than one is called a _*multi-dimensional array**. Le matrici multidimensionali di dimensioni specifiche sono spesso denominate matrici bidimensionali, matrici tridimensionali e così via.Specific sized multi-dimensional arrays are often referred to as two-dimensional arrays, three-dimensional arrays, and so on.

A ogni dimensione di una matrice è associata una lunghezza che è un numero integrale maggiore o uguale a zero.Each dimension of an array has an associated length which is an integral number greater than or equal to zero. Le lunghezze delle dimensioni non fanno parte del tipo della matrice, bensì vengono stabilite quando viene creata un'istanza del tipo di matrice in fase di esecuzione.The dimension lengths are not part of the type of the array, but rather are established when an instance of the array type is created at run-time. La lunghezza di una dimensione determina l'intervallo di indici validi per la dimensione: per una dimensione di lunghezza N , gli indici possono variare da 0 a N - 1 inclusivo.The length of a dimension determines the valid range of indices for that dimension: For a dimension of length N, indices can range from 0 to N - 1 inclusive. Il numero totale di elementi in una matrice è il prodotto delle lunghezze di ogni dimensione della matrice.The total number of elements in an array is the product of the lengths of each dimension in the array. Se una o più dimensioni di una matrice hanno una lunghezza pari a zero, la matrice viene detta vuota.If one or more of the dimensions of an array have a length of zero, the array is said to be empty.

L'elemento di una matrice può essere di qualsiasi tipo, anche di tipo matrice.The element type of an array can be any type, including an array type.

Tipi matriceArray types

Un tipo di matrice viene scritto come non_array_type seguito da uno o più rank_specifier s:An array type is written as a non_array_type followed by one or more rank_specifier s:

array_type
    : non_array_type rank_specifier+
    ;

non_array_type
    : type
    ;

rank_specifier
    : '[' dim_separator* ']'
    ;

dim_separator
    : ','
    ;

Un non_array_type è qualsiasi tipo che non è A sua volta una array_type.A non_array_type is any type that is not itself an array_type.

Il numero di dimensioni di un tipo di matrice viene fornito dal rank_specifier più a sinistra nell' array_type: un rank_specifier indica che la matrice è una matrice con un rango di uno più il numero di , token "" nel rank_specifier.The rank of an array type is given by the leftmost rank_specifier in the array_type: A rank_specifier indicates that the array is an array with a rank of one plus the number of "," tokens in the rank_specifier.

Il tipo di elemento di un tipo matrice è il tipo risultante dall'eliminazione dell' rank_specifier più a sinistra:The element type of an array type is the type that results from deleting the leftmost rank_specifier:

  • Un tipo di matrice del form T[R] è una matrice con rango R e un tipo di elemento non di matrice T .An array type of the form T[R] is an array with rank R and a non-array element type T.
  • Un tipo di matrice del form T[R][R1]...[Rn] è una matrice con rango R e un tipo di elemento T[R1]...[Rn] .An array type of the form T[R][R1]...[Rn] is an array with rank R and an element type T[R1]...[Rn].

In effetti, il rank_specifier s viene letto da sinistra a destra prima del tipo di elemento non matrice finale.In effect, the rank_specifier s are read from left to right before the final non-array element type. Il tipo int[][,,][,] è una matrice unidimensionale di matrici tridimensionali di matrici bidimensionali di int .The type int[][,,][,] is a single-dimensional array of three-dimensional arrays of two-dimensional arrays of int.

In fase di esecuzione, un valore di un tipo di matrice può essere null o un riferimento a un'istanza di tale tipo di matrice.At run-time, a value of an array type can be null or a reference to an instance of that array type.

Tipo System. ArrayThe System.Array type

Il tipo System.Array è il tipo di base astratto di tutti i tipi di matrice.The type System.Array is the abstract base type of all array types. Una conversione implicita di riferimenti (conversioni implicite di riferimento) esiste da qualsiasi tipo di matrice a System.Array e una conversione esplicita dei riferimenti (conversioni di riferimenti espliciti) esiste da System.Array a qualsiasi tipo di matrice.An implicit reference conversion (Implicit reference conversions) exists from any array type to System.Array, and an explicit reference conversion (Explicit reference conversions) exists from System.Array to any array type. Si noti che System.Array non è a sua volta un array_type.Note that System.Array is not itself an array_type. Piuttosto, si tratta di un class_type da cui derivano tutti i array_type.Rather, it is a class_type from which all array_type s are derived.

In fase di esecuzione, un valore di tipo System.Array può essere null o un riferimento a un'istanza di qualsiasi tipo di matrice.At run-time, a value of type System.Array can be null or a reference to an instance of any array type.

Matrici e interfaccia IList genericaArrays and the generic IList interface

Una matrice unidimensionale T[] implementa l'interfaccia System.Collections.Generic.IList<T> ( IList<T> per breve) e le relative interfacce di base.A one-dimensional array T[] implements the interface System.Collections.Generic.IList<T> (IList<T> for short) and its base interfaces. Di conseguenza, esiste una conversione implicita da T[] a IList<T> e dalle relative interfacce di base.Accordingly, there is an implicit conversion from T[] to IList<T> and its base interfaces. Inoltre, se esiste una conversione implicita di un riferimento da S a, T S[] implementa IList<T> ed esiste una conversione implicita di riferimenti da S[] a e dalle IList<T> relative interfacce di base (conversioni implicite dei riferimenti).In addition, if there is an implicit reference conversion from S to T then S[] implements IList<T> and there is an implicit reference conversion from S[] to IList<T> and its base interfaces (Implicit reference conversions). Se è presente una conversione esplicita di un riferimento da S a T , esiste una conversione esplicita del riferimento da S[] a IList<T> e dalle relative interfacce di base (conversioni esplicite dei riferimenti).If there is an explicit reference conversion from S to T then there is an explicit reference conversion from S[] to IList<T> and its base interfaces (Explicit reference conversions). Ad esempio:For example:

using System.Collections.Generic;

class Test
{
    static void Main() {
        string[] sa = new string[5];
        object[] oa1 = new object[5];
        object[] oa2 = sa;

        IList<string> lst1 = sa;                    // Ok
        IList<string> lst2 = oa1;                   // Error, cast needed
        IList<object> lst3 = sa;                    // Ok
        IList<object> lst4 = oa1;                   // Ok

        IList<string> lst5 = (IList<string>)oa1;    // Exception
        IList<string> lst6 = (IList<string>)oa2;    // Ok
    }
}

L'assegnazione lst2 = oa1 genera un errore in fase di compilazione poiché la conversione da object[] a IList<string> è una conversione esplicita, non implicita.The assignment lst2 = oa1 generates a compile-time error since the conversion from object[] to IList<string> is an explicit conversion, not implicit. Il cast (IList<string>)oa1 causerà la generazione di un'eccezione in fase di esecuzione, perché oa1 fa riferimento a object[] e non a string[] .The cast (IList<string>)oa1 will cause an exception to be thrown at run-time since oa1 references an object[] and not a string[]. Tuttavia, il cast (IList<string>)oa2 non comporterà la generazione di un'eccezione poiché oa2 fa riferimento a un oggetto string[] .However the cast (IList<string>)oa2 will not cause an exception to be thrown since oa2 references a string[].

Ogni volta che viene eseguita una conversione implicita o esplicita di un riferimento da S[] a IList<T> , esiste anche una conversione esplicita del riferimento da IList<T> e dalle relative interfacce di base a S[] (conversioni esplicite dei riferimenti).Whenever there is an implicit or explicit reference conversion from S[] to IList<T>, there is also an explicit reference conversion from IList<T> and its base interfaces to S[] (Explicit reference conversions).

Quando un tipo di matrice S[] implementa IList<T> , alcuni dei membri dell'interfaccia implementata possono generare eccezioni.When an array type S[] implements IList<T>, some of the members of the implemented interface may throw exceptions. Il comportamento preciso dell'implementazione dell'interfaccia esula dall'ambito di questa specifica.The precise behavior of the implementation of the interface is beyond the scope of this specification.

creazione di matriciArray creation

Le istanze di matrice vengono create da array_creation_expression s (espressioni di creazione di matrici) o da dichiarazioni di variabili locali o di campo che includono una array_initializer (inizializzatori di matrice).Array instances are created by array_creation_expression s (Array creation expressions) or by field or local variable declarations that include an array_initializer (Array initializers).

Quando viene creata un'istanza di matrice, il rango e la lunghezza di ogni dimensione vengono stabiliti e rimangono costanti per l'intera durata dell'istanza.When an array instance is created, the rank and length of each dimension are established and then remain constant for the entire lifetime of the instance. In altre parole, non è possibile modificare il rango di un'istanza di matrice esistente né ridimensionarne le dimensioni.In other words, it is not possible to change the rank of an existing array instance, nor is it possible to resize its dimensions.

Un'istanza di matrice è sempre di tipo matrice.An array instance is always of an array type. Il System.Array tipo è un tipo astratto di cui non è possibile creare un'istanza.The System.Array type is an abstract type that cannot be instantiated.

Gli elementi delle matrici create da array_creation_expression s vengono sempre inizializzati sul valore predefinito (valori predefiniti).Elements of arrays created by array_creation_expression s are always initialized to their default value (Default values).

Accesso agli elementi di matriceArray element access

Gli elementi della matrice sono accessibili tramite espressioni di element_access (accesso alla matrice) nel formato A[I1, I2, ..., In] , dove A è un'espressione di un tipo matrice e ogni Ix espressione è un'espressione di tipo int ,,, uint long ulong o può essere convertita in modo implicito in uno o più di questi tipi.Array elements are accessed using element_access expressions (Array access) of the form A[I1, I2, ..., In], where A is an expression of an array type and each Ix is an expression of type int, uint, long, ulong, or can be implicitly converted to one or more of these types. Il risultato di un accesso a un elemento della matrice è una variabile, ovvero l'elemento di matrice selezionato dagli indici.The result of an array element access is a variable, namely the array element selected by the indices.

Gli elementi di una matrice possono essere enumerati usando un' foreach istruzione (l'istruzione foreach).The elements of an array can be enumerated using a foreach statement (The foreach statement).

Membri di matriceArray members

Ogni tipo di matrice eredita i membri dichiarati dal System.Array tipo.Every array type inherits the members declared by the System.Array type.

Covarianza di matriciArray covariance

Per due reference_type A e B , se esiste una conversione implicita dei riferimenti (conversioni di riferimenti impliciti) o una conversione esplicita del riferimento (conversioni esplicitedi riferimento) da A a B , la stessa conversione del riferimento esiste anche dal tipo A[R] di matrice al tipo di matrice B[R] , dove R è qualsiasi rank_specifier (ma lo stesso per entrambi i tipi di matrice).For any two reference_type s A and B, if an implicit reference conversion (Implicit reference conversions) or explicit reference conversion (Explicit reference conversions) exists from A to B, then the same reference conversion also exists from the array type A[R] to the array type B[R], where R is any given rank_specifier (but the same for both array types). Questa relazione è nota come covarianza di matrici.This relationship is known as array covariance. In particolare, la covarianza di matrici indica che un valore di un tipo di matrice A[R] può essere effettivamente un riferimento a un'istanza di un tipo matrice B[R] , purché esista una conversione implicita di riferimento da B a A .Array covariance in particular means that a value of an array type A[R] may actually be a reference to an instance of an array type B[R], provided an implicit reference conversion exists from B to A.

A causa della covarianza di matrice, le assegnazioni a elementi di matrici di tipi di riferimento includono un controllo Runtime che garantisce che il valore assegnato all'elemento di matrice sia effettivamente di un tipo consentito (assegnazione semplice).Because of array covariance, assignments to elements of reference type arrays include a run-time check which ensures that the value being assigned to the array element is actually of a permitted type (Simple assignment). Ad esempio:For example:

class Test
{
    static void Fill(object[] array, int index, int count, object value) {
        for (int i = index; i < index + count; i++) array[i] = value;
    }

    static void Main() {
        string[] strings = new string[100];
        Fill(strings, 0, 100, "Undefined");
        Fill(strings, 0, 10, null);
        Fill(strings, 90, 10, 0);
    }
}

L'assegnazione a array[i] nel Fill metodo include implicitamente un controllo in fase di esecuzione che garantisce che l'oggetto a cui fa riferimento value sia null o un'istanza di compatibile con il tipo di elemento effettivo di array .The assignment to array[i] in the Fill method implicitly includes a run-time check which ensures that the object referenced by value is either null or an instance that is compatible with the actual element type of array. In Main , le prime due chiamate di hanno Fill esito positivo, ma la terza chiamata genera un' System.ArrayTypeMismatchException eccezione durante l'esecuzione della prima assegnazione a array[i] .In Main, the first two invocations of Fill succeed, but the third invocation causes a System.ArrayTypeMismatchException to be thrown upon executing the first assignment to array[i]. L'eccezione si verifica perché int non è possibile archiviare un oggetto boxed in una string matrice.The exception occurs because a boxed int cannot be stored in a string array.

La covarianza della matrice non si estende in modo specifico alle matrici di value_type s.Array covariance specifically does not extend to arrays of value_type s. Ad esempio, non esiste alcuna conversione che consenta a un oggetto int[] di essere considerato come object[] .For example, no conversion exists that permits an int[] to be treated as an object[].

Inizializzatori di matriceArray initializers

Gli inizializzatori di matrice possono essere specificati in dichiarazioni di campo (campi), dichiarazioni di variabili locali (dichiarazioni di variabili locali) ed espressioni di creazione di matrici (espressioni di creazione di matrici):Array initializers may be specified in field declarations (Fields), local variable declarations (Local variable declarations), and array creation expressions (Array creation expressions):

array_initializer
    : '{' variable_initializer_list? '}'
    | '{' variable_initializer_list ',' '}'
    ;

variable_initializer_list
    : variable_initializer (',' variable_initializer)*
    ;

variable_initializer
    : expression
    | array_initializer
    ;

Un inizializzatore di matrice è costituito da una sequenza di inizializzatori di variabile, racchiusi tra { token "" e " } " e separati da , token "".An array initializer consists of a sequence of variable initializers, enclosed by "{" and "}" tokens and separated by "," tokens. Ogni inizializzatore di variabile è un'espressione o, nel caso di una matrice multidimensionale, un inizializzatore di matrice annidato.Each variable initializer is an expression or, in the case of a multi-dimensional array, a nested array initializer.

Il contesto in cui viene utilizzato un inizializzatore di matrice determina il tipo della matrice da inizializzare.The context in which an array initializer is used determines the type of the array being initialized. In un'espressione di creazione di matrici, il tipo di matrice precede immediatamente l'inizializzatore o viene dedotto dalle espressioni nell'inizializzatore di matrice.In an array creation expression, the array type immediately precedes the initializer, or is inferred from the expressions in the array initializer. In una dichiarazione di campo o di variabile, il tipo di matrice è il tipo del campo o della variabile da dichiarare.In a field or variable declaration, the array type is the type of the field or variable being declared. Quando viene usato un inizializzatore di matrice in una dichiarazione di campo o di variabile, ad esempio:When an array initializer is used in a field or variable declaration, such as:

int[] a = {0, 2, 4, 6, 8};

si tratta semplicemente di una sintassi abbreviata per un'espressione di creazione di matrici equivalente:it is simply shorthand for an equivalent array creation expression:

int[] a = new int[] {0, 2, 4, 6, 8};

Per una matrice unidimensionale, l'inizializzatore di matrice deve essere costituito da una sequenza di espressioni che sono compatibili con il tipo di elemento della matrice.For a single-dimensional array, the array initializer must consist of a sequence of expressions that are assignment compatible with the element type of the array. Le espressioni inizializzano gli elementi della matrice in ordine crescente, iniziando con l'elemento in corrispondenza dell'indice zero.The expressions initialize array elements in increasing order, starting with the element at index zero. Il numero di espressioni nell'inizializzatore di matrice determina la lunghezza dell'istanza della matrice da creare.The number of expressions in the array initializer determines the length of the array instance being created. Ad esempio, l'inizializzatore di matrice precedente crea un' int[] istanza di lunghezza 5 e quindi Inizializza l'istanza con i valori seguenti:For example, the array initializer above creates an int[] instance of length 5 and then initializes the instance with the following values:

a[0] = 0; a[1] = 2; a[2] = 4; a[3] = 6; a[4] = 8;

Per una matrice multidimensionale, l'inizializzatore di matrice deve avere un numero di livelli di nidificazione pari al numero di dimensioni nella matrice.For a multi-dimensional array, the array initializer must have as many levels of nesting as there are dimensions in the array. Il livello di nidificazione più esterno corrisponde alla dimensione più a sinistra e il livello di nidificazione più interno corrisponde alla dimensione più a destra.The outermost nesting level corresponds to the leftmost dimension and the innermost nesting level corresponds to the rightmost dimension. La lunghezza di ogni dimensione della matrice è determinata dal numero di elementi a livello di annidamento corrispondente nell'inizializzatore di matrice.The length of each dimension of the array is determined by the number of elements at the corresponding nesting level in the array initializer. Per ogni inizializzatore di matrice annidato, il numero di elementi deve essere uguale a quello degli altri inizializzatori di matrice allo stesso livello.For each nested array initializer, the number of elements must be the same as the other array initializers at the same level. Esempio:The example:

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

Crea una matrice bidimensionale con una lunghezza di cinque per la dimensione più a sinistra e una lunghezza di due per la dimensione più a destra:creates a two-dimensional array with a length of five for the leftmost dimension and a length of two for the rightmost dimension:

int[,] b = new int[5, 2];

quindi Inizializza l'istanza di matrice con i valori seguenti:and then initializes the array instance with the following values:

b[0, 0] = 0; b[0, 1] = 1;
b[1, 0] = 2; b[1, 1] = 3;
b[2, 0] = 4; b[2, 1] = 5;
b[3, 0] = 6; b[3, 1] = 7;
b[4, 0] = 8; b[4, 1] = 9;

Se una dimensione diversa da quella a destra viene specificata con la lunghezza zero, si presuppone che anche le dimensioni successive abbiano una lunghezza pari a zero.If a dimension other than the rightmost is given with length zero, the subsequent dimensions are assumed to also have length zero. Esempio:The example:

int[,] c = {};

Crea una matrice bidimensionale con una lunghezza pari a zero sia per la dimensione più a sinistra che per quella più a destra:creates a two-dimensional array with a length of zero for both the leftmost and the rightmost dimension:

int[,] c = new int[0, 0];

Quando un'espressione di creazione di matrici include sia lunghezze della dimensione esplicita che un inizializzatore di matrice, le lunghezze devono essere espressioni costanti e il numero di elementi a ogni livello di annidamento deve corrispondere alla lunghezza della dimensione corrispondente.When an array creation expression includes both explicit dimension lengths and an array initializer, the lengths must be constant expressions and the number of elements at each nesting level must match the corresponding dimension length. Ecco alcuni esempi:Here are some examples:

int i = 3;
int[] x = new int[3] {0, 1, 2};        // OK
int[] y = new int[i] {0, 1, 2};        // Error, i not a constant
int[] z = new int[3] {0, 1, 2, 3};     // Error, length/initializer mismatch

In questo caso, l'inizializzatore per y genera un errore in fase di compilazione perché l'espressione della lunghezza della dimensione non è una costante e l'inizializzatore per z genera un errore in fase di compilazione perché la lunghezza e il numero di elementi nell'inizializzatore non concordano.Here, the initializer for y results in a compile-time error because the dimension length expression is not a constant, and the initializer for z results in a compile-time error because the length and the number of elements in the initializer do not agree.