Matrici in Visual BasicArrays in Visual Basic

Una matrice è un set di valori, che sono suddivisi elementi, che sono correlate logicamente tra loro.An array is a set of values, which are termed elements, that are logically related to each other. Ad esempio, può essere costituito da una matrice del numero di studenti iscritti a ciascun anno scolastico di una scuola elementare; ogni elemento della matrice è il numero di studenti in un singolo livello.For example, an array may consist of the number of students in each grade in a grammar school; each element of the array is the number of students in a single grade. Analogamente, può essere costituito da una matrice di voti di uno studente per una classe. ogni elemento della matrice è un singolo livello.Similarly, an array may consist of a student's grades for a class; each element of the array is a single grade.

È possibile singole variabili per archiviare ogni elementi di dati.It is possible individual variables to store each of our data items. Ad esempio, se l'applicazione analizza valutazioni dello studente, è possibile usare una variabile separata per ogni valutazione dello studente, ad esempio englishGrade1, englishGrade2e così via. Questo approccio presenta tre limitazioni principali:For example, if our application analyzes student grades, we can use a separate variable for each student's grade, such as englishGrade1, englishGrade2, etc. This approach has three major limitations:

  • È necessario sapere in fase di progettazione esattamente quante valutazioni dobbiamo gestire.We have to know at design time exactly how many grades we have to handle.
  • Gestisce un numero elevato di voti rapidamente diventa difficile da gestire.Handling large numbers of grades quickly becomes unwieldy. Ciò rende a sua volta un'applicazione molto più probabile contenere bug gravi.This in turn makes an application much more likely to have serious bugs.
  • È difficile da gestire.It is difficult to maintain. Ogni livello nuovo che aggiungiamo richiede che l'applicazione essere modificata, ricompilata e ridistribuita.Each new grade that we add requires that the application be modified, recompiled, and redeployed.

Usando una matrice, è possibile fare riferimento a questi valori correlati mediante lo stesso nome e usare un numero che viene chiamato un' indice oppure pedice per identificare un singolo elemento in base alla posizione nella matrice.By using an array, you can refer to these related values by the same name, and use a number that’s called an index or subscript to identify an individual element based on its position in the array. Gli indici di una matrice sono compresi tra 0 per il numero totale di elementi della matrice meno uno.The indexes of an array range from 0 to one less than the total number of elements in the array. Quando si usa Visual Basic sintassi per definire le dimensioni di una matrice, specificare il relativo indice più alto, non il numero totale di elementi nella matrice.When you use Visual Basic syntax to define the size of an array, you specify its highest index, not the total number of elements in the array. È possibile usare la matrice come un'unità e la possibilità di eseguire l'iterazione dei relativi elementi si evita di dover conoscere esattamente quanti elementi in esso contenuti in fase di progettazione.You can work with the array as a unit, and the ability to iterate its elements frees you from needing to know exactly how many elements it contains at design time.

Di seguito sono riportati alcuni esempi:Some quick examples before explanation:

' Declare a single-dimension array of 5 numbers.
Dim numbers(4) As Integer

' Declare a single-dimension array and set its 4 values.
Dim numbers = New Integer() {1, 2, 4, 8}

' Change the size of an existing array to 16 elements and retain the current values.
ReDim Preserve numbers(15)

' Redefine the size of an existing array and reset the values.
ReDim numbers(15)

' Declare a 6 x 6 multidimensional array.
Dim matrix(5, 5) As Double

' Declare a 4 x 3 multidimensional array and set array element values.
Dim matrix = New Integer(3, 2) {{1, 2, 3}, {2, 3, 4}, {3, 4, 5}, {4, 5, 6}}

' Declare a jagged array
Dim sales()() As Double = New Double(11)() {}

Elementi della matrice in una matrice sempliceArray elements in a simple array

È possibile creare una matrice denominata students per archiviare il numero degli studenti iscritti a ciascun anno scolastico di una scuola elementare.Let's create an array named students to store the number of students in each grade in a grammar school. Gli indici degli elementi sono compresi tra 0 e 6.The indexes of the elements range from 0 through 6. L'uso di questa matrice è più semplice rispetto alla dichiarazione di sette variabili.Using this array is simpler than declaring seven variables.

La figura seguente illustra il students matrice.The following illustration shows the students array. Per ogni elemento della matrice:For each element of the array:

  • L'indice dell'elemento rappresenta l'anno scolastico (l'indice 0 rappresenta l'asilo).The index of the element represents the grade (index 0 represents kindergarten).

  • Il valore contenuto nell'elemento rappresenta il numero degli studenti iscritti a tale anno scolastico.The value that’s contained in the element represents the number of students in that grade.

Diagramma che mostra una matrice di numeri di studenti

L'esempio seguente contiene il codice Visual Basic che crea e Usa la matrice:The following example contains the Visual Basic code that creates and uses the array:


Module SimpleArray
   Public Sub Main()
      ' Declare an array with 7 elements.
      Dim students(6) As Integer

      ' Assign values to each element.
      students(0) = 23
      students(1) = 19
      students(2) = 21
      students(3) = 17
      students(4) = 19
      students(5) = 20
      students(6) = 22
      
      ' Display the value of each element.
      For ctr As Integer = 0 To 6
         Dim grade As String = If(ctr = 0, "kindergarten", $"grade {ctr}")
         Console.WriteLine($"Students in {grade}: {students(ctr)}")
      Next
   End Sub
End Module
' The example displays the following output:
'     Students in kindergarten: 23
'     Students in grade 1: 19
'     Students in grade 2: 21
'     Students in grade 3: 17
'     Students in grade 4: 19
'     Students in grade 5: 20
'     Students in grade 6: 22

L'esempio effettua tre operazioni:The example does three things:

  • Dichiara un students matrice con sette elementi.It declares a students array with seven elements. Il numero 6 nella matrice di dichiarazione indica l'ultimo indice nella matrice; uno è minore del numero di elementi nella matrice.The number 6 in the array declaration indicates the last index in the array; it is one less than the number of elements in the array.
  • Assegna valori a ogni elemento nella matrice.It assigns values to each element in the array. Gli elementi della matrice sono accessibili tramite il nome della matrice e includendo l'indice dell'elemento singole racchiuso tra parentesi.Array elements are accessed by using the array name and including the index of the individual element in parentheses.
  • Elenca ogni valore della matrice.It lists each value of the array. L'esempio Usa un' For istruzione per accedere a ogni elemento della matrice dal relativo numero di indice.The example uses a For statement to access each element of the array by its index number.

Il students matrice nell'esempio precedente è una matrice unidimensionale, perché usa un indice.The students array in the preceding example is a one-dimensional array because it uses one index. Matrice che usa più di un indice o indice viene chiamata multidimensionali.An array that uses more than one index or subscript is called multidimensional. Per altre informazioni, vedere il resto di questo articolo e Array Dimensions in Visual Basic.For more information, see the rest of this article and Array Dimensions in Visual Basic.

Creazione di una matriceCreating an array

È possibile definire le dimensioni della matrice in diversi modi:You can define the size of an array in several ways:

  • È possibile specificare le dimensioni quando la matrice viene dichiarata:You can specify the size when the array is declared:

    ' Declare an array with 10 elements.
    Dim cargoWeights(9) As Double               
    ' Declare a 24 x 2 array.
    Dim hourlyTemperatures(23, 1) As Integer
    ' Declare a jagged array with 31 elements.
    Dim januaryInquiries(30)() As String
    
  • È possibile usare un New clausola per specificare la dimensione di una matrice al momento della creazione:You can use a New clause to supply the size of an array when it’s created:

    ' Declare an array with 10 elements.
    Dim cargoWeights(9) As Double
    ' Declare a 24 x 2 array.
    Dim hourlyTemperatures(23, 1) As Integer
    ' Declare a jagged array with 31 elements. 
    Dim januaryInquiries(30)() As String
    

Se si dispone di una matrice esistente, è possibile ridefinirne la dimensione utilizzando la ReDim istruzione.If you have an existing array, you can redefine its size by using the ReDim statement. È possibile specificare che il ReDim istruzione mantenere i valori nella matrice o è possibile specificare la creazione di una matrice vuota.You can specify that the ReDim statement keep the values that are in the array, or you can specify that it create an empty array. L'esempio seguente illustra vari modi di usare l'istruzione ReDim per modificare la dimensione di una matrice esistente.The following example shows different uses of the ReDim statement to modify the size of an existing array.

' Assign a new array size and retain the current values.
ReDim Preserve cargoWeights(20)
' Assign a new array size and retain only the first five values.
ReDim Preserve cargoWeights(4)
' Assign a new array size and discard all current element values.
ReDim cargoWeights(15)

Per altre informazioni, vedere la istruzione ReDim.For more information, see the ReDim Statement.

Archiviazione di valori in una matriceStoring values in an array

È possibile accedere a ogni posizione in una matrice usando un indice di tipo Integer.You can access each location in an array by using an index of type Integer. È possibile archiviare e recuperare i valori in una matrice facendo riferimento a ogni posizione della matrice tramite il relativo indice racchiuso tra parentesi.You can store and retrieve values in an array by referencing each array location by using its index enclosed in parentheses. Gli indici per le matrici multidimensionali sono separati da virgole (,).Indexes for multidimensional arrays are separated by commas (,). È necessario un indice per ogni dimensione della matrice.You need one index for each array dimension.

Nell'esempio seguente illustra alcune istruzioni che archiviano e recuperano i valori nelle matrici.The following example shows some statements that store and retrieve values in arrays.


Module Example
   Public Sub Main()
      ' Create a 10-element integer array.
      Dim numbers(9) As Integer
      Dim value As Integer = 2
        
      ' Write values to it.
      For ctr As Integer = 0 To 9
         numbers(ctr) = value
         value *= 2
      Next
        
      ' Read and sum the array values.  
      Dim sum As Integer
      For ctr As Integer = 0 To 9
         sum += numbers(ctr)
      Next
      Console.WriteLine($"The sum of the values is {sum:N0}")
    End Sub
End Module
' The example displays the following output:
'     The sum of the values is 2,046

Popolamento di una matrice con valori letterali di matricePopulating an array with array literals

Usando un valore letterale di matrice, è possibile popolare una matrice con un set iniziale di valori nello stesso momento creazione.By using an array literal, you can populate an array with an initial set of values at the same time that you create it. Un valore letterale di matrice è costituito da un elenco di valori delimitati da virgole racchiusi tra parentesi graffe ({}).An array literal consists of a list of comma-separated values that are enclosed in braces ({}).

Quando si usa un valore letterale di matrice per creare una matrice, è possibile specificare il tipo o usare l'inferenza del tipo per determinare il tipo di matrice.When you create an array by using an array literal, you can either supply the array type or use type inference to determine the array type. Nell'esempio seguente illustra entrambe le opzioni.The following example shows both options.

' Array literals with explicit type definition.
Dim numbers = New Integer() {1, 2, 4, 8}
' Array literals with type inference.
Dim doubles = {1.5, 2, 9.9, 18}
' Array literals with explicit type definition.
Dim articles() As String = { "the", "a", "an" }

' Array literals with explicit widening type definition.
Dim values() As Double = { 1, 2, 3, 4, 5 }

Quando si usa l'inferenza del tipo, il tipo della matrice è determinato dal tipo dominante nell'elenco di valori letterali.When you use type inference, the type of the array is determined by the dominant type in the list of literal values. Il tipo dominante è il tipo a cui è possono ingrandire tutti gli altri tipi nella matrice.The dominant type is the type to which all other types in the array can widen. Se non è possibile determinare il tipo univoco, il tipo dominante è il tipo univoco in cui possono restringersi tutti gli altri tipi nella matrice.If this unique type can’t be determined, the dominant type is the unique type to which all other types in the array can narrow. Se nessuno di questi tipi univoci può essere determinato, il tipo dominante è Object.If neither of these unique types can be determined, the dominant type is Object. Se, ad esempio, l'elenco di valori fornito al valore letterale di matrice contiene valori di tipo Integer, Longe Double, la matrice risultante è di tipo Double.For example, if the list of values that’s supplied to the array literal contains values of type Integer, Long, and Double, the resulting array is of type Double. In quanto Integer e Long possono ampliarsi solo nel Double, Double è il tipo dominante.Because Integer and Long widen only to Double, Double is the dominant type. Per altre informazioni, vedere Widening and Narrowing Conversions.For more information, see Widening and Narrowing Conversions.

Nota

È possibile usare l'inferenza del tipo solo per le matrici che sono definite come variabili locali in un membro del tipo.You can use type inference only for arrays that are defined as local variables in a type member. Se è presente una definizione di tipo esplicito, le matrici definite con valori letterali di matrice a livello di classe sono di tipo Object[].If an explicit type definition is absent, arrays defined with array literals at the class level are of type Object[]. Per altre informazioni, vedere inferenza del tipo locale.For more information, see Local type inference.

Si noti che nell'esempio precedente viene definito values come una matrice di tipo Double anche se tutti i valori letterali della matrice sono di tipo Integer.Note that the previous example defines values as an array of type Double even though all the array literals are of type Integer. È possibile creare questa matrice perché i valori nel valore letterale di matrice possono ampliarsi Double valori.You can create this array because the values in the array literal can widen to Double values.

È anche possibile creare e popolare una matrice multidimensionale usando valori letterali di matrice annidati.You can also create and populate a multidimensional array by using nested array literals. Valori letterali di matrice annidati devono avere un numero di dimensioni che è coerenza con la matrice risultante.Nested array literals must have a number of dimensions that’s consistent with the resulting array. L'esempio seguente crea una matrice bidimensionale di interi con valori letterali di matrice annidati.The following example creates a two-dimensional array of integers by using nested array literals.

' Create and populate a 2 x 2 array.
Dim grid1 = {{1, 2}, {3, 4}}
' Create and populate a 2 x 2 array with 3 elements.
Dim grid2(,) = {{1, 2}, {3, 4}, {5, 6}}

Quando si usano valori letterali di matrice annidati per creare e popolare una matrice, si verifica un errore se il numero di elementi nei valori letterali di matrice annidati non corrisponda.When using nested array literals to create and populate an array, an error occurs if the number of elements in the nested array literals don't match. Si verifica un errore anche se si dichiara in modo esplicito la variabile di matrice per avere un numero diverso di dimensioni rispetto a valori letterali della matrice.An error also occurs if you explicitly declare the array variable to have a different number of dimensions than the array literals.

Proprio come per le matrici unidimensionali, è possibile basarsi sull'inferenza del tipo durante la creazione di una matrice multidimensionale con valori letterali di matrice annidati.Just as you can for one-dimensional arrays, you can rely on type inference when creating a multidimensional array with nested array literals. Il tipo dedotto è il tipo dominante per tutti i valori in tutti i valori letterali di matrice per tutti i livello di nidificazione.The inferred type is the dominant type for all the values in all the array literals for all nesting level. L'esempio seguente crea una matrice bidimensionale di tipo Double[,] dai valori di tipo Integer e Double.The following example creates a two-dimensional array of type Double[,] from values that are of type Integer and Double.

Dim arr = {{1, 2.0}, {3, 4}, {5, 6}, {7, 8}}

Per altri esempi, vedere come: Inizializzare una variabile di matrice in Visual Basic.For additional examples, see How to: Initialize an Array Variable in Visual Basic.

Iterazione su una matriceIterating through an array

Quando si scorre una matrice, accedere a ogni elemento nella matrice dall'indice più basso al più elevato o dal valore massimo a quello minimo.When you iterate through an array, you access each element in the array from the lowest index to the highest or from the highest to the lowest. In genere, utilizzare il per... Istruzione successiva o il For Each... Istruzione Next per scorrere gli elementi della matrice.Typically, use either the For...Next Statement or the For Each...Next Statement to iterate through the elements of an array. Quando non si conoscono i limiti superiori della matrice, è possibile chiamare il Array.GetUpperBound metodo per ottenere il valore massimo dell'indice.When you don't know the upper bounds of the array, you can call the Array.GetUpperBound method to get the highest value of the index. Anche se il valore di indice più basso è quasi sempre 0, è possibile chiamare il Array.GetLowerBound metodo per ottenere il valore più basso dell'indice.Although lowest index value is almost always 0, you can call the Array.GetLowerBound method to get the lowest value of the index.

Nell'esempio seguente scorre una matrice unidimensionale usando il For...Next istruzione.The following example iterates through a one-dimensional array by using the For...Next statement.


Module IterateArray
   Public Sub Main()
      Dim numbers = {10, 20, 30}

      For index = 0 To numbers.GetUpperBound(0)
         Console.WriteLine(numbers(index))
      Next
   End Sub
End Module
' The example displays the following output:
'  10
'  20
'  30

Nell'esempio seguente scorre una matrice multidimensionale usando un For...Next istruzione.The following example iterates through a multidimensional array by using a For...Next statement. Il metodo GetUpperBound ha un parametro che specifica la dimensione.The GetUpperBound method has a parameter that specifies the dimension. GetUpperBound(0) Restituisce l'indice più alto della prima dimensione, e GetUpperBound(1) restituisce l'indice più alto della seconda dimensione.GetUpperBound(0) returns the highest index of the first dimension, and GetUpperBound(1) returns the highest index of the second dimension.


Module IterateArray
   Public Sub Main()
      Dim numbers = {{1, 2}, {3, 4}, {5, 6}}

      For index0 = 0 To numbers.GetUpperBound(0)
         For index1 = 0 To numbers.GetUpperBound(1)
            Console.Write($"{numbers(index0, index1)} ")
         Next
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output:
' Output 
'  1 2 
'  3 4 
'  5 6

L'esempio seguente usa un For Each... Istruzione Nextper scorrere una matrice unidimensionale e una matrice bidimensionale.The following example uses a For Each...Next Statementto iterate through a one-dimensional array and a two-dimensional array.


Module IterateWithForEach
   Public Sub Main()
      ' Declare and iterate through a one-dimensional array.
      Dim numbers1 = {10, 20, 30}
      
      For Each number In numbers1
         Console.WriteLine(number)
      Next
      Console.WriteLine()
      
      Dim numbers = {{1, 2}, {3, 4}, {5, 6}}

      For Each number In numbers
         Console.WriteLine(number)
      Next
   End Sub
End Module
' The example displays the following output:
'  10
'  20
'  30
'
'  1
'  2
'  3
'  4
'  5
'  6

Dimensione della matriceArray size

La dimensione di una matrice è il prodotto delle lunghezze di tutte le relative dimensioniThe size of an array is the product of the lengths of all its dimensions. e rappresenta il numero totale di elementi attualmente contenuti nella matrice.It represents the total number of elements currently contained in the array. Ad esempio, nell'esempio seguente dichiara una matrice bidimensionale con 2 con quattro elementi in ogni dimensione.For example, the following example declares a 2-dimensional array with four elements in each dimension. Come illustrato nell'output dell'esempio, le dimensioni della matrice sono 16 (o (3 + 1) * (3 + 1).As the output from the example shows, the array's size is 16 (or (3 + 1) * (3 + 1).


Module Example
   Public Sub Main()
      Dim arr(3, 3) As Integer
      Console.WriteLine(arr.Length)     
   End Sub
End Module
' The example displays the following output:
'     16

Nota

Questa discussione di dimensione della matrice non è applicabile per le matrici di matrici.This discussion of array size does not apply to jagged arrays. Per informazioni sulle matrici di matrici e determinare le dimensioni di una matrice di matrici, vedere la matrici irregolari sezione.For information on jagged arrays and determining the size of a jagged array, see the Jagged arrays section.

È possibile determinare le dimensioni di una matrice usando la proprietà Array.Length.You can find the size of an array by using the Array.Length property. È possibile trovare la lunghezza di ogni dimensione di una matrice multidimensionale usando il Array.GetLength (metodo).You can find the length of each dimension of a multidimensional array by using the Array.GetLength method.

È possibile ridimensionare una variabile di matrice tramite l'assegnazione di un nuovo oggetto matrice ad esso o usando il ReDim istruzione istruzione.You can resize an array variable by assigning a new array object to it or by using the ReDim Statement statement. L'esempio seguente usa il ReDim istruzione per modificare una matrice di 100 elementi in una matrice di elementi 51.The following example uses the ReDim statement to change a 100-element array to a 51-element array.


Module Example
   Public Sub Main()
      Dim arr(99) As Integer
      Console.WriteLine(arr.Length)
      
      Redim arr(50)
      Console.WriteLine(arr.Length)
   End Sub
End Module
' The example displays the following output:
'     100
'     51

 

Di seguito sono indicati alcuni elementi importanti relativi alla dimensione di una matrice.There are several things to keep in mind when dealing with the size of an array.

Lunghezza delle dimensioniDimension Length L'indice di ogni dimensione è basato su 0, ovvero che compreso tra 0 e il limite superiore.The index of each dimension is 0-based, which means it ranges from 0 to its upper bound. Pertanto, la lunghezza di una determinata dimensione è maggiore di uno rispetto al limite superiore dichiarato di tale dimensione.Therefore, the length of a given dimension is one greater than the declared upper bound of that dimension.
Limiti di lunghezzaLength Limits La lunghezza di ogni dimensione di una matrice è limitata al valore massimo dei Integer tipo di dati, ovvero Int32.MaxValue o (2 ^ 31) - 1.The length of every dimension of an array is limited to the maximum value of the Integer data type, which is Int32.MaxValue or (2 ^ 31) - 1. La dimensione totale di una matrice, tuttavia, è limitata anche dalla memoria disponibile nel sistema.However, the total size of an array is also limited by the memory available on your system. Se si tenta di inizializzare una matrice che supera la quantità di memoria disponibile, il runtime genera un OutOfMemoryException.If you attempt to initialize an array that exceeds the amount of available memory, the runtime throws an OutOfMemoryException.
Dimensione ed elementi della matriceSize and Element Size La dimensione di una matrice è indipendente dal tipo di dati dei relativi elementi.An array's size is independent of the data type of its elements. La dimensione rappresenta sempre il numero totale di elementi, non il numero di byte che consumano una quantità di memoria.The size always represents the total number of elements, not the number of bytes that they consume in memory.
Consumo di memoriaMemory Consumption Non è possibile fare ipotesi sulla modalità di archiviazione di una matrice in memoria.It is not safe to make any assumptions regarding how an array is stored in memory. L'archiviazione dipende dalla larghezza dei dati delle diverse piattaforme. Di conseguenza, è possibile che l'archiviazione di una stessa matrice richieda più memoria in un sistema a 64 bit che in un sistema a 32 bit.Storage varies on platforms of different data widths, so the same array can consume more memory on a 64-bit system than on a 32-bit system. A seconda della configurazione di sistema al momento dell'inizializzazione di una matrice, Common Language Runtime (CLR) può assegnare la memoria in modo da compattare al massimo gli elementi oppure in modo da allinearli tutti in base ai limiti dell'hardware.Depending on system configuration when you initialize an array, the common language runtime (CLR) can assign storage either to pack elements as close together as possible, or to align them all on natural hardware boundaries. Per le informazioni di controllo di una matrice è richiesto un sovraccarico di archiviazione che aumenta con ogni dimensione aggiunta.Also, an array requires a storage overhead for its control information, and this overhead increases with each added dimension.

Il tipo di matriceThe array type

Ogni matrice ha un tipo di dati che è diverso dal tipo di dati dei relativi elementi.Every array has a data type, which differs from the data type of its elements. Non esiste un singolo tipo di dati per tutte le matrici.There is no single data type for all arrays. Il tipo di dati di una matrice viene invece determinato dal numero di dimensioni, o rango, della matrice e dal tipo di dati degli elementi nella matrice.Instead, the data type of an array is determined by the number of dimensions, or rank, of the array, and the data type of the elements in the array. Due variabili di matrice sono degli stessi dati digitare solo se hanno lo stesso rango e i relativi elementi hanno gli stessi dati di tipo.Two array variables are of the same data type only when they have the same rank and their elements have the same data type. Le lunghezze delle dimensioni di una matrice non influenzano il tipo di dati della matrice.The lengths of the dimensions of an array do not influence the array data type.

Ogni matrice eredita dalla classe System.Array. È possibile dichiarare una variabile di tipo Array, ma non è possibile creare una matrice di tipo Array.Every array inherits from the System.Array class, and you can declare a variable to be of type Array, but you cannot create an array of type Array. Ad esempio, anche se il codice seguente viene dichiarata la arr variabile di tipo Array e chiama il Array.CreateInstance metodo per creare un'istanza di matrice, il tipo della matrice è senza dubbio Object [].For example, although the following code declares the arr variable to be of type Array and calls the Array.CreateInstance method to instantiate the array, the array's type proves to be Object[].


Module Example
   Public Sub Main()
      Dim arr As Array = Array.CreateInstance(GetType(Object), 19)
      Console.WriteLine(arr.Length)
      Console.WriteLine(arr.GetType().Name)
   End Sub
End Module
' The example displays the following output:
'     19
'     Object[]

L'istruzione ReDim non può inoltre operare su una variabile dichiarata di tipo Array.Also, the ReDim Statement cannot operate on a variable declared as type Array. Per questi motivi e indipendente dai tipi, è consigliabile dichiarare ogni matrice come un tipo specifico.For these reasons, and for type safety, it is advisable to declare every array as a specific type.

È possibile determinare il tipo di dati di una matrice o dei relativi elementi in diversi modi.You can find out the data type of either an array or its elements in several ways.

  • È possibile chiamare il GetType metodo sulla variabile per ottenere un Type oggetto che rappresenta il tipo di runtime della variabile.You can call the GetType method on the variable to get a Type object that represents the run-time type of the variable. Nelle proprietà e nei metodi dell'oggetto Type sono presenti informazioni complete.The Type object holds extensive information in its properties and methods.
  • È possibile passare la variabile per il TypeName funzione per ottenere un String con il nome del tipo di runtime.You can pass the variable to the TypeName function to get a String with the name of run-time type.

Nell'esempio seguente chiama la sia la GetType (metodo) e il TypeName funzione per determinare il tipo di matrice.The following example calls the both the GetType method and the TypeName function to determine the type of an array. Il tipo di matrice è Byte(,).The array type is Byte(,). Si noti che il Type.BaseType proprietà indica anche che il tipo di base della matrice di byte è il Array classe.Note that the Type.BaseType property also indicates that the base type of the byte array is the Array class.


Module Example
   Public Sub Main()
      Dim bytes(9,9) As Byte
      Console.WriteLine($"Type of {nameof(bytes)} array: {bytes.GetType().Name}")
      Console.WriteLine($"Base class of {nameof(bytes)}: {bytes.GetType().BaseType.Name}")
      Console.WriteLine()
      Console.WriteLine($"Type of {nameof(bytes)} array: {TypeName(bytes)}")
   End Sub
End Module
' The example displays the following output:
' Type of bytes array: Byte[,]
' Base class of bytes: Array
' 
' Type of bytes array: Byte(,)


Matrici come valori restituiti e parametriArrays as return values and parameters

Per restituire una matrice da una routine Function, specificare il tipo di dati della matrice e il numero di dimensioni come tipo restituito dell'istruzione Function.To return an array from a Function procedure, specify the array data type and the number of dimensions as the return type of the Function Statement. All'interno della funzione dichiarare una variabile di matrice locale con lo stesso tipo di dati degli elementi e lo stesso numero di dimensioni.Within the function, declare a local array variable with same data type and number of dimensions. Includere la variabile di matrice locale senza parentesi nell'istruzione Return.In the Return Statement, include the local array variable without parentheses.

Per specificare una matrice come parametro in una routine Sub o Function , definire il parametro come matrice con un tipo di dati e un numero di dimensioni specificati.To specify an array as a parameter to a Sub or Function procedure, define the parameter as an array with a specified data type and number of dimensions. Nella chiamata alla procedura, passare una variabile di matrice con lo stesso tipo di dati e il numero di dimensioni.In the call to the procedure, pass an array variable with the same data type and number of dimensions.

Nell'esempio seguente, il GetNumbers funzione restituisce un Integer(), una matrice unidimensionale di tipo Integer.In the following example, the GetNumbers function returns an Integer(), a one-dimensional array of type Integer. La routine ShowNumbers accetta un argomento Integer() .The ShowNumbers procedure accepts an Integer() argument.


Module ReturnValuesAndParams
   Public Sub Main()
      Dim numbers As Integer() = GetNumbers()
      ShowNumbers(numbers)
   End Sub

   Private Function GetNumbers() As Integer()
      Dim numbers As Integer() = {10, 20, 30}
      Return numbers
   End Function

   Private Sub ShowNumbers(numbers As Integer())
      For index = 0 To numbers.GetUpperBound(0)
         Console.WriteLine($"{numbers(index)} ")
      Next
   End Sub
End Module
' The example displays the following output:
'   10
'   20
'   30
    

Nell'esempio seguente, il GetNumbersMultiDim funzione restituisce un Integer(,), una matrice bidimensionale di tipo Integer.In the following example, the GetNumbersMultiDim function returns an Integer(,), a two-dimensional array of type Integer. La routine ShowNumbersMultiDim accetta un argomento Integer(,) .The ShowNumbersMultiDim procedure accepts an Integer(,) argument.


Module Example
   Public Sub Main()
      Dim numbers As Integer(,) = GetNumbersMultidim()
      ShowNumbersMultidim(numbers)
   End Sub

   Private Function GetNumbersMultidim() As Integer(,)
      Dim numbers As Integer(,) = {{1, 2}, {3, 4}, {5, 6}}
      Return numbers
   End Function

   Private Sub ShowNumbersMultidim(numbers As Integer(,))
      For index0 = 0 To numbers.GetUpperBound(0)
         For index1 = 0 To numbers.GetUpperBound(1)
            Console.Write($"{numbers(index0, index1)} ")
         Next
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output:
'     1 2
'     3 4
'     5 6

Matrici di matriciJagged arrays

In alcuni casi la struttura dei dati nell'applicazione è bidimensionale, ma non rettangolare.Sometimes the data structure in your application is two-dimensional but not rectangular. Ad esempio, si potrebbe usare una matrice per archiviare i dati sulla temperatura massima di ogni giorno del mese.For example, you might use an array to store data about the high temperature of each day of the month. La prima dimensione della matrice rappresenta il mese, ma la seconda dimensione rappresenta il numero di giorni e il numero di giorni in un mese non è uniforme.The first dimension of the array represents the month, but the second dimension represents the number of days, and the number of days in a month is not uniform. Oggetto matrice di matrici, che viene chiamato anche un' matrice di matrici, è progettato per questi scenari.A jagged array, which is also called an array of arrays, is designed for such scenarios. Una matrice irregolare è una matrice i cui elementi sono anche le matrici.A jagged array is an array whose elements are also arrays. Una matrice irregolare e ogni elemento di una matrice irregolare possono avere una o più dimensioni.A jagged array and each element in a jagged array can have one or more dimensions.

L'esempio seguente usa una matrice di mesi, ogni elemento del quale è una matrice di giorni.The following example uses an array of months, each element of which is an array of days. L'esempio Usa una matrice di matrici in quanto mesi diversi hanno numeri di giorni diversi.The example uses a jagged array because different months have different numbers of days. Nell'esempio viene illustrato come creare una matrice di matrici, assegnare i valori e recuperare e visualizzare i relativi valori.The example shows how to create a jagged array, assign values to it, and retrieve and display its values.

Imports System.Globalization

Module JaggedArray
   Public Sub Main()
      ' Declare the jagged array of 12 elements. Each element is an array of Double.
      Dim sales(11)() As Double
      ' Set each element of the sales array to a Double array of the appropriate size.
      For month As Integer = 0 To 11
         ' The number of days in the month determines the appropriate size.
         Dim daysInMonth As Integer =
            DateTime.DaysInMonth(Year(Now), month + 1)
         sales(month) = New Double(daysInMonth - 1) {}
      Next 

      ' Store values in each element.
      For month As Integer = 0 To 11
         For dayOfMonth = 0 To sales(month).GetUpperBound(0)
            sales(month)(dayOfMonth) = (month * 100) + dayOfMonth
         Next
      Next

      ' Retrieve and display the array values.
      Dim monthNames = DateTimeFormatInfo.CurrentInfo.AbbreviatedMonthNames
      ' Display the month names.
      Console.Write("    ")
      For ctr = 0 To sales.GetUpperBound(0)
         Console.Write($" {monthNames(ctr)}   ")
      Next   
      Console.WriteLine()
      ' Display data for each day in each month.
      For dayInMonth = 0 To 30
         Console.Write($"{dayInMonth + 1,2}.  ")
         For monthNumber = 0 To sales.GetUpperBound(0)
            If dayInMonth > sales(monthNumber).GetUpperBound(0) Then 
               Console.Write("       ")
            Else
               Console.Write($"{sales(monthNumber)(dayInMonth),-5}  ")
            End If
         Next   
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output:
'      Jan    Feb    Mar    Apr    May    Jun    Jul    Aug    Sep    Oct    Nov    Dec
'  1.  0      100    200    300    400    500    600    700    800    900    1000   1100
'  2.  1      101    201    301    401    501    601    701    801    901    1001   1101
'  3.  2      102    202    302    402    502    602    702    802    902    1002   1102
'  4.  3      103    203    303    403    503    603    703    803    903    1003   1103
'  5.  4      104    204    304    404    504    604    704    804    904    1004   1104
'  6.  5      105    205    305    405    505    605    705    805    905    1005   1105
'  7.  6      106    206    306    406    506    606    706    806    906    1006   1106
'  8.  7      107    207    307    407    507    607    707    807    907    1007   1107
'  9.  8      108    208    308    408    508    608    708    808    908    1008   1108
' 10.  9      109    209    309    409    509    609    709    809    909    1009   1109
' 11.  10     110    210    310    410    510    610    710    810    910    1010   1110
' 12.  11     111    211    311    411    511    611    711    811    911    1011   1111
' 13.  12     112    212    312    412    512    612    712    812    912    1012   1112
' 14.  13     113    213    313    413    513    613    713    813    913    1013   1113
' 15.  14     114    214    314    414    514    614    714    814    914    1014   1114
' 16.  15     115    215    315    415    515    615    715    815    915    1015   1115
' 17.  16     116    216    316    416    516    616    716    816    916    1016   1116
' 18.  17     117    217    317    417    517    617    717    817    917    1017   1117
' 19.  18     118    218    318    418    518    618    718    818    918    1018   1118
' 20.  19     119    219    319    419    519    619    719    819    919    1019   1119
' 21.  20     120    220    320    420    520    620    720    820    920    1020   1120
' 22.  21     121    221    321    421    521    621    721    821    921    1021   1121
' 23.  22     122    222    322    422    522    622    722    822    922    1022   1122
' 24.  23     123    223    323    423    523    623    723    823    923    1023   1123
' 25.  24     124    224    324    424    524    624    724    824    924    1024   1124
' 26.  25     125    225    325    425    525    625    725    825    925    1025   1125
' 27.  26     126    226    326    426    526    626    726    826    926    1026   1126
' 28.  27     127    227    327    427    527    627    727    827    927    1027   1127
' 29.  28            228    328    428    528    628    728    828    928    1028   1128
' 30.  29            229    329    429    529    629    729    829    929    1029   1129
' 31.  30            230           430           630    730           930           1130

Nell'esempio precedente assegna valori alla matrice di matrici in un elemento per elemento di base usando un For...Next ciclo.The previous example assigns values to the jagged array on an element-by-element basis by using a For...Next loop. È anche possibile assegnare valori agli elementi di una matrice di matrici tramite valori letterali di matrice annidati.You can also assign values to the elements of a jagged array by using nested array literals. Tuttavia, il tentativo di usare annidati valori letterali di matrice (ad esempio, Dim valuesjagged = {{1, 2}, {2, 3, 4}}) genera l'errore del compilatore BC30568.However, the attempt to use nested array literals (for example, Dim valuesjagged = {{1, 2}, {2, 3, 4}}) generates compiler error BC30568. Per correggere l'errore, racchiudere i valori letterali di matrice interni tra parentesi.To correct the error, enclose the inner array literals in parentheses. Le parentesi forzano l'espressione letterale di matrice deve essere valutata e i valori risultanti vengono usati con la matrice esterna letterale, come illustrato nell'esempio seguente.The parentheses force the array literal expression to be evaluated, and the resulting values are used with the outer array literal, as the following example shows.


Module Example
   Public Sub Main()
      Dim values1d = { 1, 2, 3 }
      Dim values2d = {{1, 2}, {2, 3}, {3, 4}}
      Dim valuesjagged = {({1, 2}), ({2, 3, 4})}
   End Sub
End Module

Una matrice di matrici è una matrice unidimensionale il cui elementi contengono le matrici.A jagged array is a one-dimensional array whose elements contain arrays. Pertanto, il Array.Length proprietà e il Array.GetLength(0) metodo restituisce il numero di elementi nella matrice unidimensionale, e Array.GetLength(1) genera un IndexOutOfRangeException perché una matrice di matrici non è multidimensionale.Therefore, the Array.Length property and the Array.GetLength(0) method return the number of elements in the one-dimensional array, and Array.GetLength(1) throws an IndexOutOfRangeException because a jagged array is not multidimensional. Determinare il numero di elementi in ogni matrice secondaria recuperando il valore di ogni sottomatrice Array.Length proprietà.You determine the number of elements in each subarray by retrieving the value of each subarray's Array.Length property. L'esempio seguente illustra come determinare il numero di elementi in una matrice di matrici.The following example illustrates how to determine the number of elements in a jagged array.


Module Example
   Public Sub Main()
      Dim jagged = { ({1, 2}), ({2, 3, 4}), ({5, 6}), ({7, 8, 9, 10}) }
      Console.WriteLine($"The value of jagged.Length: {jagged.Length}.")
      Dim total = jagged.Length
      For ctr As Integer = 0 To jagged.GetUpperBound(0)
         Console.WriteLine($"Element {ctr + 1} has {jagged(ctr).Length} elements.") 
         total += jagged(ctr).Length 
      Next
      Console.WriteLine($"The total number of elements in the jagged array: {total}")
   End Sub
End Module
' The example displays the following output:
'     The value of jagged.Length: 4.
'     Element 1 has 2 elements.
'     Element 2 has 3 elements.
'     Element 3 has 2 elements.
'     Element 4 has 4 elements.
'     The total number of elements in the jagged array: 15

Matrici di lunghezza zeroZero-length arrays

Visual Basic consente di distinguere tra una matrice non inizializzata (una matrice il cui valore è Nothing) e una matrice di lunghezza zero oppure matrice vuota (una matrice senza elementi). Una matrice non inizializzata è uno che non è stata dimensionata o avevano tutti i valori assegnati a esso.Visual Basic differentiates between a uninitialized array (an array whose value is Nothing) and a zero-length array or empty array (an array that has no elements.) An uninitialized array is one that has not been dimensioned or had any values assigned to it. Ad esempio:For example:

Dim arr() As String

Una matrice di lunghezza zero è dichiarata con una dimensione di -1.A zero-length array is declared with a dimension of -1. Ad esempio:For example:

Dim arrZ(-1) As String

Potrebbe essere necessario creare una matrice di lunghezza zero nelle circostanze seguenti:You might need to create a zero-length array under the following circumstances:

  • Senza rischiare un NullReferenceException eccezione, il codice deve accedere ai membri del Array classe, ad esempio Length oppure Rank, o chiamare una funzione di Visual Basic, ad esempio UBound.Without risking a NullReferenceException exception, your code must access members of the Array class, such as Length or Rank, or call a Visual Basic function such as UBound.

  • Si vuole mantenere il codice semplice da non dover cercare Nothing come caso speciale.You want to keep your code simple by not having to check for Nothing as a special case.

  • Il codice interagisce con un'API (Application Programming Interface) che richiede il passaggio di una matrice di lunghezza zero a una o più routine oppure che restituisce una matrice di lunghezza zero da una o più routine.Your code interacts with an application programming interface (API) that either requires you to pass a zero-length array to one or more procedures or returns a zero-length array from one or more procedures.

Suddivisione di una matriceSplitting an array

In alcuni casi, potrebbe essere necessario suddividere una singola matrice più array.In some cases, you may need to split a single array into multiple arrays. Ciò comporta che identifica il punto o i punti in corrispondenza del quale la matrice deve essere suddiviso e quindi sputare della matrice in due o più matrici separate.This involves identifying the point or points at which the array is to be split, and then spitting the array into two or more separate arrays.

Nota

In questa sezione non viene illustrata la suddivisione di una singola stringa in una matrice di stringhe in base a un delimitatore.This section does not discuss splitting a single string into a string array based on some delimiter. Per informazioni sulla suddivisione di una stringa, vedere il String.Split (metodo).For information on splitting a string, see the String.Split method.

I criteri più comuni per la suddivisione di una matrice sono:The most common criteria for splitting an array are:

  • Numero di elementi nella matrice.The number of elements in the array. Ad esempio, è possibile suddividere una matrice di più di un numero specificato di elementi in un numero di circa parti uguali.For example, you might want to split an array of more than a specified number of elements into a number of approximately equal parts. A tale scopo, è possibile usare il valore restituito in uno dei modi il Array.Length o Array.GetLength (metodo).For this purpose, you can use the value returned by either the Array.Length or Array.GetLength method.

  • Il valore di un elemento, che funge da un delimitatore che indica dove la matrice deve essere suddivisa.The value of an element, which serves as a delimiter that indicates where the array should be split. È possibile cercare un valore specifico chiamando il Array.FindIndex e Array.FindLastIndex metodi.You can search for a specific value by calling the Array.FindIndex and Array.FindLastIndex methods.

Dopo aver determinato l'indice o gli indici in corrispondenza del quale la matrice deve essere suddiviso, quindi è possibile creare matrici singole chiamando il Array.Copy (metodo).Once you've determined the index or indexes at which the array should be split, you can then create the individual arrays by calling the Array.Copy method.

Nell'esempio seguente suddivide una matrice in due matrici di dimensioni simili.The following example splits an array into two arrays of approximately equal size. (Se il numero totale di elementi della matrice è dispari, la prima matrice ha un elemento in più rispetto al secondo).(If the total number of array elements is odd, the first array has one more element than the second.)


Module Example
   Public Sub Main()
      ' Create an array of 100 elements.
      Dim arr(99) As Integer
      ' Populate the array.
      Dim rnd As new Random()
      For ctr = 0 To arr.GetUpperBound(0)
         arr(ctr) = rnd.Next()
      Next
      
      ' Determine how many elements should be in each array.
      Dim divisor = 2
      Dim remainder As Integer
      Dim boundary = Math.DivRem(arr.GetLength(0), divisor, remainder)
            
      ' Copy the array.
      Dim arr1(boundary - 1 + remainder), arr2(boundary - 1) as Integer
      Array.Copy(arr, 0, arr1, 0, boundary + remainder)
      Array.Copy(arr, boundary + remainder, arr2, 0, arr.Length - boundary) 
   End Sub
End Module

Nell'esempio seguente suddivide una matrice di stringhe in due matrici in base alla presenza di un elemento il cui valore è "zzz", che viene utilizzata come delimitatore di matrice.The following example splits a string array into two arrays based on the presence of an element whose value is "zzz", which serves as the array delimiter. Le nuove matrici non includono l'elemento che contiene il delimitatore.The new arrays do not include the element that contains the delimiter.


Module Example
   Public Sub Main()
      Dim rnd As New Random()
      
      ' Create an array of 100 elements.
      Dim arr(99) As String
      ' Populate each element with an arbitrary ASCII character.
      For ctr = 0 To arr.GetUpperBound(0)
         arr(ctr) = ChrW(Rnd.Next(&h21, &h7F))
      Next
      ' Get a random number that will represent the point to insert the delimiter.
      arr(rnd.Next(0, arr.GetUpperBound(0))) = "zzz"

      ' Find the delimiter.
      Dim location = Array.FindIndex(arr, Function(x) x = "zzz")

      ' Create the arrays.
      Dim arr1(location - 1) As String
      Dim arr2(arr.GetUpperBound(0) - location - 1) As String
      
      ' Populate the two arrays.
      Array.Copy(arr, 0, arr1, 0, location)
      Array.Copy(arr, location + 1, arr2, 0, arr.GetUpperBound(0) - location)
   End Sub
End Module

Aggiunta di matriciJoining arrays

È anche possibile combinare un numero di matrici in una singola matrice di dimensioni maggiori.You can also combine a number of arrays into a single larger array. A tale scopo, utilizziamo inoltre il Array.Copy (metodo).To do this, you also use the Array.Copy method.

Nota

In questa sezione non viene illustrata l'aggiunta di una matrice di stringhe in un'unica stringa.This section does not discuss joining a string array into a single string. Per informazioni sull'aggiunta di una matrice di stringhe, vedere il String.Join (metodo).For information on joining a string array, see the String.Join method.

Prima di copiare gli elementi di ogni matrice nella matrice di nuovo, è necessario assicurarsi che è stata inizializzata la matrice in modo che sia grande abbastanza da contenere la nuova matrice.Before copying the elements of each array into the new array, you must first ensure that you have initialized the array so that it is large enough to accommodate the new array. Questa operazione può essere eseguita in due modi:You can do this in one of two ways:

  • Usare la ReDim Preserve espandere in modo dinamico la matrice prima di aggiungervi nuovi elementi dell'istruzione.Use the ReDim Preserve statement to dynamically expand the array before adding new elements to it. Si tratta della tecnica più semplice, ma può comportare una riduzione delle prestazioni e utilizzo di memoria eccessiva quando si copiano le matrici di grandi dimensioni.This is the easiest technique, but it can result in performance degradation and excessive memory consumption when you are copying large arrays.
  • Calcolare il numero totale di elementi necessari per la nuova matrice di grandi dimensioni, quindi aggiungere gli elementi di ogni matrice di origine a esso.Calculate the total number of elements needed for the new large array, then add the elements of each source array to it.

Nell'esempio seguente usa il secondo approccio per aggiungere quattro matrici con dieci elementi in una singola matrice.The following example uses the second approach to add four arrays with ten elements each to a single array.

Imports System.Collections.Generic
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim tasks As New List(Of Task(Of Integer()))
      ' Generate four arrays.
      For ctr = 0 To 3
         Dim value = ctr
         tasks.Add(Task.Run(Function()
                               Dim arr(9) As Integer
                               For ndx = 0 To arr.GetUpperBound(0)
                                  arr(ndx) = value
                               Next
                               Return arr
                            End Function))   
       Next
       Task.WaitAll(tasks.ToArray())
       ' Compute the number of elements in all arrays.
       Dim elements = 0
       For Each task In tasks
          elements += task.Result.Length
       Next
       Dim newArray(elements - 1) As Integer
       Dim index = 0
       For Each task In tasks
          Dim n = task.Result.Length
          Array.Copy(task.Result, 0, newArray, index, n)
          index += n
       Next 
      Console.WriteLine($"The new array has {newArray.Length} elements.")
   End Sub
End Module
' The example displays the following output:
'     The new array has 40 elements.

Poiché in questo caso le matrici di origine sono tutti piccole, è possibile espandere inoltre in modo dinamico la matrice man mano che si aggiungono gli elementi di ogni nuova matrice a esso.Since in this case the source arrays are all small, we can also dynamically expand the array as we add the elements of each new array to it. Nell'esempio seguente viene eseguita questa operazione.The following example does that.

Imports System.Collections.Generic
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim tasks As New List(Of Task(Of Integer()))
      ' Generate four arrays.
      For ctr = 0 To 3
         Dim value = ctr
         tasks.Add(Task.Run(Function()
                               Dim arr(9) As Integer
                               For ndx = 0 To arr.GetUpperBound(0)
                                  arr(ndx) = value
                               Next
                               Return arr
                            End Function))   
       Next
       Task.WaitAll(tasks.ToArray())

       ' Dimension the target array and copy each element of each source array to it.
       Dim newArray() As Integer = {}
       ' Define the next position to copy to in newArray.
       Dim index = 0
       For Each task In tasks
          Dim n = Task.Result.Length
          ReDim Preserve newArray(newArray.GetUpperBound(0) + n)
          Array.Copy(task.Result, 0, newArray, index, n)
          index += n
       Next 
      Console.WriteLine($"The new array has {newArray.Length} elements.")
   End Sub
End Module
' The example displays the following output:
'     The new array has 40 elements.

Raccolte come alternativa alle matriciCollections as an alternative to arrays

Le matrici sono estremamente utili per la creazione e l'uso di un numero fisso di oggetti fortemente tipizzati.Arrays are most useful for creating and working with a fixed number of strongly typed objects. Le raccolte consentono di lavorare in modo più flessibile con gruppi di oggetti.Collections provide a more flexible way to work with groups of objects. A differenza delle matrici, che richiede che si modificano in modo esplicito le dimensioni di una matrice con il ReDim istruzione, raccolte di aumentare e diminuire dinamicamente in base alle esigenze di un'applicazione viene modificata.Unlike arrays, which require that you explicitly change the size of an array with the ReDim Statement, collections grow and shrink dynamically as the needs of an application change.

Quando si usa ReDim per ridimensionare una matrice, Visual Basic crea una nuova matrice e rilascia in quella precedente.When you use ReDim to redimension an array, Visual Basic creates a new array and releases the previous one. Questa operazione causa un aumento del tempo di esecuzione.This takes execution time. Pertanto, se il numero di elementi che si sta lavorando cambia spesso oppure è possibile prevedere il numero massimo di elementi che necessari, è in genere sarà ottenere prestazioni migliori usando una raccolta.Therefore, if the number of items you are working with changes frequently, or you cannot predict the maximum number of items you need, you'll usually obtain better performance by using a collection.

Per alcune raccolte è possibile assegnare una chiave a qualsiasi oggetto inserito nella raccolta in modo da recuperare rapidamente l'oggetto usando la chiave.For some collections, you can assign a key to any object that you put into the collection so that you can quickly retrieve the object by using the key.

Se la raccolta contiene elementi di un solo tipo di dati, è possibile usare una delle classi nello spazio dei nomi System.Collections.Generic .If your collection contains elements of only one data type, you can use one of the classes in the System.Collections.Generic namespace. In una raccolta generica viene imposta l'indipendenza dai tipi, in modo da impedire che vengano aggiunti altri tipi di dati alla raccolta.A generic collection enforces type safety so that no other data type can be added to it.

Per altre informazioni sulle raccolte, vedere Raccolte.For more information about collections, see Collections.

TermineTerm DefinizioneDefinition
Array Dimensions in Visual BasicArray Dimensions in Visual Basic Illustra il numero di dimensioni, o rango, e le dimensioni delle matrici.Explains rank and dimensions in arrays.
Procedura: Inizializzare una variabile di matrice in Visual BasicHow to: Initialize an Array Variable in Visual Basic Descrive come popolare le matrici con valori iniziali.Describes how to populate arrays with initial values.
Procedura: Sort An Array in Visual BasicHow to: Sort An Array in Visual Basic Illustra come ordinare alfabeticamente gli elementi di una matrice.Shows how to sort the elements of an array alphabetically.
Procedura: Assegnare una matrice a un'altra matriceHow to: Assign One Array to Another Array Descrive regole e passaggi per l'assegnazione di una matrice a un'altra variabile di matrice.Describes the rules and steps for assigning an array to another array variable.
Risoluzione dei problemi relativi alle matriciTroubleshooting Arrays Illustra alcuni problemi comuni che si verificano quando si usano le matrici.Discusses some common problems that arise when working with arrays.

Vedere ancheSee also