Array Classe

Definizione

Spazio dei nomi:

System

Assembly:

System.Runtime.dll

Origine:

Array.cs

Fornisce metodi per la creazione, la modifica, la ricerca e l'ordinamento di matrici, in modo da fungere da classe di base per tutte le matrici in Common Language Runtime.

public ref class Array abstract : ICloneable, System::Collections::IList, System::Collections::IStructuralComparable, System::Collections::IStructuralEquatable

public abstract class Array : ICloneable, System.Collections.IList, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable

type Array = class
    interface ICollection
    interface IEnumerable
    interface IList
    interface IStructuralComparable
    interface IStructuralEquatable
    interface ICloneable

Public MustInherit Class Array
Implements ICloneable, IList, IStructuralComparable, IStructuralEquatable

Ereditarietà

Object

Array

Implementazioni

ICollection IEnumerable IList IStructuralComparable IStructuralEquatable ICloneable

Esempio

Nell'esempio di codice seguente viene illustrato come Array.Copy copia gli elementi tra una matrice di tipo integer e una matrice di tipo Object.

using namespace System;

void PrintValues(array<Object^>^myArr);
void PrintValues(array<int>^myArr);
void main()
{
    // Creates and initializes a new int array and a new Object array.
    array<int>^myIntArray = { 1,2,3,4,5 };
    array<Object^>^myObjArray = { 26,27,28,29,30 };

    // Prints the initial values of both arrays.
    Console::WriteLine("Initially:");
    Console::Write("int array:   ");
    PrintValues(myIntArray);
    Console::Write("Object array:");
    PrintValues(myObjArray);

    // Copies the first two elements from the int array to the Object array.
    System::Array::Copy(myIntArray, myObjArray, 2);

    // Prints the values of the modified arrays.
    Console::WriteLine("\nAfter copying the first two elements of the int array to the Object array:");
    Console::Write("int array:   ");
    PrintValues(myIntArray);
    Console::Write("Object array:");
    PrintValues(myObjArray);

    // Copies the last two elements from the Object array to the int array.
    System::Array::Copy(myObjArray, myObjArray->GetUpperBound(0) - 1, myIntArray, myIntArray->GetUpperBound(0) - 1, 2);

    // Prints the values of the modified arrays.
    Console::WriteLine("\nAfter copying the last two elements of the Object array to the int array:");
    Console::Write("int array:   ");
    PrintValues(myIntArray);
    Console::Write("Object array:");
    PrintValues(myObjArray);
}

void PrintValues(array<Object^>^myArr)
{
    for (int i = 0; i < myArr->Length; i++)
    {
        Console::Write("\t{0}", myArr[i]);

    }
    Console::WriteLine();
}

void PrintValues(array<int>^myArr)
{
    for (int i = 0; i < myArr->Length; i++)
    {
        Console::Write("\t{0}", myArr[i]);

    }
    Console::WriteLine();
}


/*
This code produces the following output.

Initially:
int array:       1    2    3    4    5
Object array:    26    27    28    29    30
After copying the first two elements of the int array to the Object array:
int array:       1    2    3    4    5
Object array:    1    2    28    29    30
After copying the last two elements of the Object array to the int array:
int array:       1    2    3    29    30
Object array:    1    2    28    29    30
*/

open System

let printValues myArr =
    for i in myArr do
        printf $"\t{i}"
    printfn ""

// Creates and initializes a new integer array and a new Object array.
let myIntArray = [| 1..5 |]
let myObjArray = [| 26..30 |]

// Prints the initial values of both arrays.
printfn "Initially,"
printf "integer array:"
printValues myIntArray
printfn "Object array: "
printValues myObjArray

// Copies the first two elements from the integer array to the Object array.
Array.Copy(myIntArray, myObjArray, 2)

// Prints the values of the modified arrays.
printfn "\nAfter copying the first two elements of the integer array to the Object array,"
printf "integer array:"
printValues myIntArray
printf"Object array: "
printValues myObjArray

// Copies the last two elements from the Object array to the integer array.
Array.Copy(myObjArray, myObjArray.GetUpperBound 0 - 1, myIntArray, myIntArray.GetUpperBound 0 - 1, 2)

// Prints the values of the modified arrays.
printfn $"\nAfter copying the last two elements of the Object array to the integer array,"
printf "integer array:"
printValues myIntArray
printf "Object array: "
printValues myObjArray


// This code produces the following output.
//     Initially,
//     integer array:  1       2       3       4       5
//     Object array:   26      27      28      29      30
//     
//     After copying the first two elements of the integer array to the Object array,
//     integer array:  1       2       3       4       5
//     Object array:   1       2       28      29      30
//     
//     After copying the last two elements of the Object array to the integer array,
//     integer array:  1       2       3       29      30
//     Object array:   1       2       28      29      30

using System;
public class SamplesArray
{

    public static void Main()
    {

        // Creates and initializes a new integer array and a new Object array.
        int[] myIntArray = new int[5] { 1, 2, 3, 4, 5 };
        Object[] myObjArray = new Object[5] { 26, 27, 28, 29, 30 };

        // Prints the initial values of both arrays.
        Console.WriteLine("Initially,");
        Console.Write("integer array:");
        PrintValues(myIntArray);
        Console.Write("Object array: ");
        PrintValues(myObjArray);

        // Copies the first two elements from the integer array to the Object array.
        System.Array.Copy(myIntArray, myObjArray, 2);

        // Prints the values of the modified arrays.
        Console.WriteLine("\nAfter copying the first two elements of the integer array to the Object array,");
        Console.Write("integer array:");
        PrintValues(myIntArray);
        Console.Write("Object array: ");
        PrintValues(myObjArray);

        // Copies the last two elements from the Object array to the integer array.
        System.Array.Copy(myObjArray, myObjArray.GetUpperBound(0) - 1, myIntArray, myIntArray.GetUpperBound(0) - 1, 2);

        // Prints the values of the modified arrays.
        Console.WriteLine("\nAfter copying the last two elements of the Object array to the integer array,");
        Console.Write("integer array:");
        PrintValues(myIntArray);
        Console.Write("Object array: ");
        PrintValues(myObjArray);
    }

    public static void PrintValues(Object[] myArr)
    {
        foreach (Object i in myArr)
        {
            Console.Write("\t{0}", i);
        }
        Console.WriteLine();
    }

    public static void PrintValues(int[] myArr)
    {
        foreach (int i in myArr)
        {
            Console.Write("\t{0}", i);
        }
        Console.WriteLine();
    }
}
/*
This code produces the following output.

Initially,
integer array:  1       2       3       4       5
Object array:   26      27      28      29      30

After copying the first two elements of the integer array to the Object array,
integer array:  1       2       3       4       5
Object array:   1       2       28      29      30

After copying the last two elements of the Object array to the integer array,
integer array:  1       2       3       29      30
Object array:   1       2       28      29      30
*/

Public Class SamplesArray

    Public Shared Sub Main()

        ' Creates and initializes a new integer array and a new Object array.
        Dim myIntArray() As Integer = {1, 2, 3, 4, 5}
        Dim myObjArray() As Object = {26, 27, 28, 29, 30}

        ' Prints the initial values of both arrays.
        Console.WriteLine("Initially:")
        Console.Write("integer array:")
        PrintValues(myIntArray)
        Console.Write("Object array: ")
        PrintValues(myObjArray)

        ' Copies the first two elements from the integer array to the Object array.
        System.Array.Copy(myIntArray, myObjArray, 2)

        ' Prints the values of the modified arrays.
        Console.WriteLine(ControlChars.NewLine + "After copying the first two" _
           + " elements of the integer array to the Object array:")
        Console.Write("integer array:")
        PrintValues(myIntArray)
        Console.Write("Object array: ")
        PrintValues(myObjArray)

        ' Copies the last two elements from the Object array to the integer array.
        System.Array.Copy(myObjArray, myObjArray.GetUpperBound(0) - 1, myIntArray,
           myIntArray.GetUpperBound(0) - 1, 2)

        ' Prints the values of the modified arrays.
        Console.WriteLine(ControlChars.NewLine + "After copying the last two" _
           + " elements of the Object array to the integer array:")
        Console.Write("integer array:")
        PrintValues(myIntArray)
        Console.Write("Object array: ")
        PrintValues(myObjArray)
    End Sub

    Public Overloads Shared Sub PrintValues(myArr() As Object)
        Dim i As Object
        For Each i In myArr
            Console.Write(ControlChars.Tab + "{0}", i)
        Next i
        Console.WriteLine()
    End Sub

    Public Overloads Shared Sub PrintValues(myArr() As Integer)
        Dim i As Integer
        For Each i In myArr
            Console.Write(ControlChars.Tab + "{0}", i)
        Next i
        Console.WriteLine()
    End Sub
End Class

' This code produces the following output.
' 
' Initially:
' integer array:  1       2       3       4       5
' Object array:   26      27      28      29      30
' 
' After copying the first two elements of the integer array to the Object array:
' integer array:  1       2       3       4       5
' Object array:   1       2       28      29      30
' 
' After copying the last two elements of the Object array to the integer array:
' integer array:  1       2       3       29      30
' Object array:   1       2       28      29      30

Nell'esempio di codice seguente viene creato e inizializzato un Array e vengono visualizzate le relative proprietà e i relativi elementi.

using namespace System;
void PrintValues(Array^ myArr);
void main()
{
   // Creates and initializes a new three-dimensional Array instance of type Int32.
   Array^ myArr = Array::CreateInstance( Int32::typeid, 2, 3, 4 );
   for ( int i = myArr->GetLowerBound( 0 ); i <= myArr->GetUpperBound( 0 ); i++ )
   {
      for ( int j = myArr->GetLowerBound( 1 ); j <= myArr->GetUpperBound( 1 ); j++ )
      {
         for ( int k = myArr->GetLowerBound( 2 ); k <= myArr->GetUpperBound( 2 ); k++ )
            myArr->SetValue( (i * 100) + (j * 10) + k, i, j, k );

      }
   }
   
   // Displays the properties of the Array.
   Console::WriteLine(  "The Array instance has {0} dimension(s) and a total of {1} elements.", myArr->Rank, myArr->Length );
   Console::WriteLine(  "\tLength\tLower\tUpper" );
   for ( int i = 0; i < myArr->Rank; i++ )
   {
      Console::Write(  "{0}:\t{1}", i, myArr->GetLength( i ) );
      Console::WriteLine(  "\t{0}\t{1}", myArr->GetLowerBound( i ), myArr->GetUpperBound( i ) );

   }
   Console::WriteLine(  "The Array instance contains the following values:" );
   PrintValues( myArr );
}

void PrintValues( Array^ myArr )
{
   System::Collections::IEnumerator^ myEnumerator = myArr->GetEnumerator();
   int i = 0;
   int cols = myArr->GetLength( myArr->Rank - 1 );
   while ( myEnumerator->MoveNext() )
   {
      if ( i < cols )
            i++;
      else
      {
         Console::WriteLine();
         i = 1;
      }

      Console::Write(  "\t{0}", myEnumerator->Current );
   }

   Console::WriteLine();
}

/* 
 This code produces the following output.
 
 The Array instance has 3 dimension(s) and a total of 24 elements.
     Length    Lower    Upper
 0:    2    0    1
 1:    3    0    2
 2:    4    0    3
 The Array instance contains the following values:
     0    1    2    3
     10    11    12    13
     20    21    22    23
     100    101    102    103
     110    111    112    113
     120    121    122    123
 */

open System

let printValues (myArray: Array) =
    let mutable i = 0
    let cols = myArray.GetLength(myArray.Rank - 1)
    for item in myArray do
        if i < cols then
            i <- i + 1
        else
            printfn ""
            i <- 1;
        printf $"\t{item}"
    printfn ""

// Creates and initializes a new three-dimensional Array of type int.
let myArr = Array.CreateInstance(typeof<int>, 2, 3, 4)
for i = myArr.GetLowerBound 0 to myArr.GetUpperBound 0 do
    for j = myArr.GetLowerBound 1 to myArr.GetUpperBound 1 do
        for k = myArr.GetLowerBound 2 to myArr.GetUpperBound 2 do
            myArr.SetValue(i * 100 + j * 10 + k, i, j, k)

// Displays the properties of the Array.
printfn $"The Array has {myArr.Rank} dimension(s) and a total of {myArr.Length} elements."
printfn $"\tLength\tLower\tUpper"

for i = 0 to myArr.Rank - 1 do
    printf $"{i}:\t{myArr.GetLength i}"
    printfn $"\t{myArr.GetLowerBound i}\t{myArr.GetUpperBound i}"

// Displays the contents of the Array.
printfn "The Array contains the following values:"
printValues myArr

// This code produces the following output.
// The Array has 3 dimension(s) and a total of 24 elements.
//     Length    Lower    Upper
// 0:  2    0    1
// 1:  3    0    2
// 2:  4    0    3
//
// The Array contains the following values:
//    0      1      2      3
//    10     11     12     13
//    20     21     22     23
//    100    101    102    103
//    110    111    112    113
//    120    121    122    123

// Creates and initializes a new three-dimensional Array of type int.
Array myArr = Array.CreateInstance(typeof(int), 2, 3, 4);
for (int i = myArr.GetLowerBound(0); i <= myArr.GetUpperBound(0); i++)
{
    for (int j = myArr.GetLowerBound(1); j <= myArr.GetUpperBound(1); j++)
    {
        for (int k = myArr.GetLowerBound(2); k <= myArr.GetUpperBound(2); k++)
        {
            myArr.SetValue((i * 100) + (j * 10) + k, i, j, k);
        }
    }
}

// Displays the properties of the Array.
Console.WriteLine("The Array has {0} dimension(s) and a total of {1} elements.", myArr.Rank, myArr.Length);
Console.WriteLine("\tLength\tLower\tUpper");
for (int i = 0; i < myArr.Rank; i++)
{
    Console.Write("{0}:\t{1}", i, myArr.GetLength(i));
    Console.WriteLine("\t{0}\t{1}", myArr.GetLowerBound(i), myArr.GetUpperBound(i));
}

// Displays the contents of the Array.
Console.WriteLine("The Array contains the following values:");
PrintValues(myArr);

void PrintValues(Array myArray)
{
    System.Collections.IEnumerator myEnumerator = myArray.GetEnumerator();
    int i = 0;
    int cols = myArray.GetLength(myArray.Rank - 1);
    while (myEnumerator.MoveNext())
    {
        if (i < cols)
        {
            i++;
        }
        else
        {
            Console.WriteLine();
            i = 1;
        }
        Console.Write("\t{0}", myEnumerator.Current);
    }
    Console.WriteLine();
}
// This code produces the following output.

// The Array has 3 dimension(s) and a total of 24 elements.
//     Length    Lower    Upper
// 0:  2    0    1
// 1:  3    0    2
// 2:  4    0    3
//
// The Array contains the following values:
//    0      1      2      3
//    10     11     12     13
//    20     21     22     23
//    100    101    102    103
//    110    111    112    113
//    120    121    122    123

Public Class SamplesArray2

    Public Shared Sub Main()

        ' Creates and initializes a new three-dimensional Array of
        ' type Int32.
        Dim myArr As Array = Array.CreateInstance(GetType(Int32), 2, 3, 4)
        Dim i As Integer
        For i = myArr.GetLowerBound(0) To myArr.GetUpperBound(0)
            Dim j As Integer
            For j = myArr.GetLowerBound(1) To myArr.GetUpperBound(1)
                Dim k As Integer
                For k = myArr.GetLowerBound(2) To myArr.GetUpperBound(2)
                    myArr.SetValue(i * 100 + j * 10 + k, i, j, k)
                Next k
            Next j
        Next i ' Displays the properties of the Array.
        Console.WriteLine("The Array has {0} dimension(s) and a " _
           + "total of {1} elements.", myArr.Rank, myArr.Length)
        Console.WriteLine(ControlChars.Tab + "Length" + ControlChars.Tab _
           + "Lower" + ControlChars.Tab + "Upper")
        For i = 0 To myArr.Rank - 1
            Console.Write("{0}:" + ControlChars.Tab + "{1}", i,
               myArr.GetLength(i))
            Console.WriteLine(ControlChars.Tab + "{0}" + ControlChars.Tab _
               + "{1}", myArr.GetLowerBound(i), myArr.GetUpperBound(i))
        Next i

        ' Displays the contents of the Array.
        Console.WriteLine("The Array contains the following values:")
        PrintValues(myArr)
    End Sub

    Public Shared Sub PrintValues(myArr As Array)
        Dim myEnumerator As System.Collections.IEnumerator =
           myArr.GetEnumerator()
        Dim i As Integer = 0
        Dim cols As Integer = myArr.GetLength(myArr.Rank - 1)
        While myEnumerator.MoveNext()
            If i < cols Then
                i += 1
            Else
                Console.WriteLine()
                i = 1
            End If
            Console.Write(ControlChars.Tab + "{0}", myEnumerator.Current)
        End While
        Console.WriteLine()
    End Sub
End Class

' This code produces the following output.
' 
' The Array has 3 dimension(s) and a total of 24 elements.
'     Length    Lower    Upper
' 0:    2    0    1
' 1:    3    0    2
' 2:    4    0    3
' The Array contains the following values:
'     0    1    2    3
'     10    11    12    13
'     20    21    22    23
'     100    101    102    103
'     110    111    112    113
'     120    121    122    123

Commenti

La classe Array non fa parte degli spazi dei nomi System.Collections. Tuttavia, è ancora considerato una raccolta perché si basa sull'interfaccia IList.

La classe Array è la classe base per le implementazioni del linguaggio che supportano matrici. Tuttavia, solo il sistema e i compilatori possono derivare in modo esplicito dalla classe Array. Gli utenti devono usare i costrutti di matrice forniti dal linguaggio.

Un elemento è un valore in un Array. La lunghezza di un Array è il numero totale di elementi che può contenere. Il limite inferiore di un Array è l'indice del primo elemento. Un Array può avere un limite inferiore, ma ha un limite inferiore pari a zero per impostazione predefinita. È possibile definire un limite inferiore diverso quando si crea un'istanza della classe Array usando CreateInstance. Un Array multidimensionale può avere limiti diversi per ogni dimensione. Una matrice può avere un massimo di 32 dimensioni.

A differenza delle classi negli spazi dei nomi System.Collections, Array ha una capacità fissa. Per aumentare la capacità, è necessario creare un nuovo oggetto Array con la capacità richiesta, copiare gli elementi dall'oggetto Array precedente a quello nuovo ed eliminare il vecchio Array.

Le dimensioni della matrice sono limitate a un totale di 4 miliardi di elementi e a un indice massimo di 0X7FEFFFFF in una determinata dimensione (0X7FFFFFC7 per matrici di byte e matrici di strutture a byte singolo).

solo .NET Framework: Per impostazione predefinita, le dimensioni massime di un Array sono di 2 gigabyte (GB). In un ambiente a 64 bit, è possibile evitare la restrizione delle dimensioni impostando l'attributo enabled dell'gcAllowVeryLargeObjects elemento di configurazione per true nell'ambiente di runtime.

Le matrici unidimensionali implementano le interfacce generiche System.Collections.Generic.IList<T>, System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyList<T> e System.Collections.Generic.IReadOnlyCollection<T> generiche. Le implementazioni vengono fornite alle matrici in fase di esecuzione e, di conseguenza, le interfacce generiche non vengono visualizzate nella sintassi di dichiarazione per la classe Array. Inoltre, non sono disponibili argomenti di riferimento per i membri dell'interfaccia accessibili solo eseguendo il cast di una matrice al tipo di interfaccia generico (implementazioni esplicite dell'interfaccia). L'aspetto principale da tenere presente quando si esegue il cast di una matrice a una di queste interfacce è che i membri che aggiungono, inseriscono o rimuovono elementi generano NotSupportedException.

Type oggetti forniscono informazioni sulle dichiarazioni dei tipi di matrice. Array oggetti con lo stesso tipo di matrice condividono lo stesso oggetto Type.

Type.IsArray e Type.GetElementType potrebbero non restituire i risultati previsti con Array perché se viene eseguito il cast di una matrice al tipo Array, il risultato è un oggetto, non una matrice. Ovvero, typeof(System.Array).IsArray restituisce falsee typeof(System.Array).GetElementType restituisce null.

Il metodo Array.Copy copia gli elementi non solo tra matrici dello stesso tipo, ma anche tra matrici standard di tipi diversi; gestisce automaticamente il cast dei tipi.

Alcuni metodi, ad esempio CreateInstance, Copy, CopyTo, GetValuee SetValue, forniscono overload che accettano interi a 64 bit come parametri per contenere matrici di capacità di grandi dimensioni. LongLength e GetLongLength restituiscono numeri interi a 64 bit che indicano la lunghezza della matrice.

Non è garantito l'ordinamento del Array. È necessario ordinare il Array prima di eseguire operazioni , ad esempio BinarySearch, che richiedono l'ordinamento del Array.

L'uso di un oggetto Array di puntatori nel codice nativo non è supportato e genererà un NotSupportedException per diversi metodi.

Proprietà

IsFixedSize	Ottiene un valore che indica se la Array ha una dimensione fissa.
IsReadOnly	Ottiene un valore che indica se il Array è di sola lettura.
IsSynchronized	Ottiene un valore che indica se l'accesso al Array è sincronizzato (thread-safe).
Length	Ottiene il numero totale di elementi in tutte le dimensioni del Array.
LongLength	Ottiene un numero intero a 64 bit che rappresenta il numero totale di elementi in tutte le dimensioni del Array.
MaxLength	Ottiene il numero massimo di elementi che possono essere contenuti in una matrice.
Rank	Ottiene il rango (numero di dimensioni) del Array. Ad esempio, una matrice unidimensionale restituisce 1, una matrice bidimensionale restituisce 2 e così via.
SyncRoot	Ottiene un oggetto che può essere utilizzato per sincronizzare l'accesso al Array.

Metodi

AsReadOnly<T>(T[])	Restituisce un wrapper di sola lettura per la matrice specificata.
BinarySearch(Array, Int32, Int32, Object)	Cerca un intervallo di elementi in una matrice ordinata unidimensionale per un valore, usando l'interfaccia IComparable implementata da ogni elemento della matrice e dal valore specificato.
BinarySearch(Array, Int32, Int32, Object, IComparer)	Cerca un intervallo di elementi in una matrice ordinata unidimensionale per un valore, usando l'interfaccia di IComparer specificata.
BinarySearch(Array, Object)	Cerca un intero array ordinato unidimensionale per un elemento specifico, utilizzando l'interfaccia IComparable implementata da ogni elemento della matrice e dall'oggetto specificato.
BinarySearch(Array, Object, IComparer)	Cerca un valore in un'intera matrice ordinata unidimensionale usando l'interfaccia di IComparer specificata.
BinarySearch<T>(T[], Int32, Int32, T)	Cerca un intervallo di elementi in una matrice ordinata unidimensionale per un valore, usando l'interfaccia generica IComparable<T> implementata da ogni elemento del Array e dal valore specificato.
BinarySearch<T>(T[], Int32, Int32, T, IComparer<T>)	Cerca un intervallo di elementi in una matrice ordinata unidimensionale per un valore, usando l'interfaccia IComparer<T> generica specificata.
BinarySearch<T>(T[], T)	Cerca un intero oggetto ordinato unidimensionale per un elemento specifico, utilizzando l'interfaccia generica IComparable<T> implementata da ogni elemento del Array e dall'oggetto specificato.
BinarySearch<T>(T[], T, IComparer<T>)	Cerca un valore in un'intera matrice ordinata unidimensionale usando l'interfaccia generica IComparer<T> specificata.
Clear(Array)	Cancella il contenuto di una matrice.
Clear(Array, Int32, Int32)	Imposta un intervallo di elementi in una matrice sul valore predefinito di ogni tipo di elemento.
Clone()	Crea una copia superficiale del Array.
ConstrainedCopy(Array, Int32, Array, Int32, Int32)	Copia un intervallo di elementi da un Array a partire dall'indice di origine specificato e li incolla in un altro Array a partire dall'indice di destinazione specificato. Garantisce che tutte le modifiche vengano annullate se la copia non riesce completamente.
ConvertAll<TInput,TOutput>(TInput[], Converter<TInput,TOutput>)	Converte una matrice di un tipo in una matrice di un altro tipo.
Copy(Array, Array, Int32)	Copia un intervallo di elementi da un Array a partire dal primo elemento e li incolla in un altro Array a partire dal primo elemento. La lunghezza viene specificata come intero a 32 bit.
Copy(Array, Array, Int64)	Copia un intervallo di elementi da un Array a partire dal primo elemento e li incolla in un altro Array a partire dal primo elemento. La lunghezza viene specificata come intero a 64 bit.
Copy(Array, Int32, Array, Int32, Int32)	Copia un intervallo di elementi da un Array a partire dall'indice di origine specificato e li incolla in un altro Array a partire dall'indice di destinazione specificato. La lunghezza e gli indici vengono specificati come interi a 32 bit.
Copy(Array, Int64, Array, Int64, Int64)	Copia un intervallo di elementi da un Array a partire dall'indice di origine specificato e li incolla in un altro Array a partire dall'indice di destinazione specificato. La lunghezza e gli indici vengono specificati come interi a 64 bit.
CopyTo(Array, Int32)	Copia tutti gli elementi della matrice unidimensionale corrente nella matrice unidimensionale specificata a partire dall'indice della matrice di destinazione specificato. L'indice viene specificato come intero a 32 bit.
CopyTo(Array, Int64)	Copia tutti gli elementi della matrice unidimensionale corrente nella matrice unidimensionale specificata a partire dall'indice della matrice di destinazione specificato. L'indice viene specificato come intero a 64 bit.
CreateInstance(Type, Int32)	Crea una Array unidimensionale della Type e della lunghezza specificate, con indicizzazione in base zero.
CreateInstance(Type, Int32, Int32)	Crea un Array bidimensionale delle lunghezze di Type e dimensione specificate, con indicizzazione in base zero.
CreateInstance(Type, Int32, Int32, Int32)	Crea un Array tridimensionale delle lunghezze di Type e dimensione specificate, con indicizzazione in base zero.
CreateInstance(Type, Int32[])	Crea un Array multidimensionale delle lunghezze di Type e dimensione specificate, con indicizzazione in base zero. Le lunghezze delle dimensioni vengono specificate in una matrice di interi a 32 bit.
CreateInstance(Type, Int32[], Int32[])	Crea un Array multidimensionale delle Type e delle lunghezze delle dimensioni specificate, con i limiti inferiori specificati.
CreateInstance(Type, Int64[])	Crea un Array multidimensionale delle lunghezze di Type e dimensione specificate, con indicizzazione in base zero. Le lunghezze delle dimensioni vengono specificate in una matrice di interi a 64 bit.
Empty<T>()	Restituisce una matrice vuota.
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
Exists<T>(T[], Predicate<T>)	Determina se la matrice specificata contiene elementi che corrispondono alle condizioni definite dal predicato specificato.
Fill<T>(T[], T)	Assegna il value di tipo specificato T a ogni elemento del arrayspecificato.
Fill<T>(T[], T, Int32, Int32)	Assegna il value di tipo specificato T agli elementi del array specificato che si trovano all'interno dell'intervallo di startIndex (inclusivo) e al numero di indici successivo count.
Find<T>(T[], Predicate<T>)	Cerca un elemento che corrisponde alle condizioni definite dal predicato specificato e restituisce la prima occorrenza all'interno dell'intero Array.
FindAll<T>(T[], Predicate<T>)	Recupera tutti gli elementi che corrispondono alle condizioni definite dal predicato specificato.
FindIndex<T>(T[], Int32, Int32, Predicate<T>)	Cerca un elemento che corrisponde alle condizioni definite dal predicato specificato e restituisce l'indice in base zero della prima occorrenza all'interno dell'intervallo di elementi nella Array che inizia in corrispondenza dell'indice specificato e contiene il numero specificato di elementi.
FindIndex<T>(T[], Int32, Predicate<T>)	Cerca un elemento che corrisponde alle condizioni definite dal predicato specificato e restituisce l'indice in base zero della prima occorrenza all'interno dell'intervallo di elementi nella Array che si estende dall'indice specificato all'ultimo elemento.
FindIndex<T>(T[], Predicate<T>)	Cerca un elemento che corrisponde alle condizioni definite dal predicato specificato e restituisce l'indice in base zero della prima occorrenza all'interno dell'intero Array.
FindLast<T>(T[], Predicate<T>)	Cerca un elemento che corrisponde alle condizioni definite dal predicato specificato e restituisce l'ultima occorrenza all'interno dell'intero Array.
FindLastIndex<T>(T[], Int32, Int32, Predicate<T>)	Cerca un elemento che corrisponde alle condizioni definite dal predicato specificato e restituisce l'indice in base zero dell'ultima occorrenza all'interno dell'intervallo di elementi nella Array che contiene il numero specificato di elementi e termina in corrispondenza dell'indice specificato.
FindLastIndex<T>(T[], Int32, Predicate<T>)	Cerca un elemento che corrisponde alle condizioni definite dal predicato specificato e restituisce l'indice in base zero dell'ultima occorrenza all'interno dell'intervallo di elementi nella Array che si estende dal primo elemento all'indice specificato.
FindLastIndex<T>(T[], Predicate<T>)	Cerca un elemento che corrisponde alle condizioni definite dal predicato specificato e restituisce l'indice in base zero dell'ultima occorrenza all'interno dell'intero Array.
ForEach<T>(T[], Action<T>)	Esegue l'azione specificata su ogni elemento della matrice specificata.
GetEnumerator()	Restituisce un IEnumerator per il Array.
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetLength(Int32)	Ottiene un numero intero a 32 bit che rappresenta il numero di elementi nella dimensione specificata della Array.
GetLongLength(Int32)	Ottiene un numero intero a 64 bit che rappresenta il numero di elementi nella dimensione specificata della Array.
GetLowerBound(Int32)	Ottiene l'indice del primo elemento della dimensione specificata nella matrice.
GetType()	Ottiene il Type dell'istanza corrente. (Ereditato da Object)
GetUpperBound(Int32)	Ottiene l'indice dell'ultimo elemento della dimensione specificata nella matrice.
GetValue(Int32)	Ottiene il valore in corrispondenza della posizione specificata nell'Arrayunidimensionale . L'indice viene specificato come intero a 32 bit.
GetValue(Int32, Int32)	Ottiene il valore in corrispondenza della posizione specificata nell'Arraybidimensionale . Gli indici vengono specificati come interi a 32 bit.
GetValue(Int32, Int32, Int32)	Ottiene il valore in corrispondenza della posizione specificata nell'Arraytridimensionale . Gli indici vengono specificati come interi a 32 bit.
GetValue(Int32[])	Ottiene il valore in corrispondenza della posizione specificata nel Arraymultidimensionale . Gli indici vengono specificati come matrice di interi a 32 bit.
GetValue(Int64)	Ottiene il valore in corrispondenza della posizione specificata nell'Arrayunidimensionale . L'indice viene specificato come intero a 64 bit.
GetValue(Int64, Int64)	Ottiene il valore in corrispondenza della posizione specificata nell'Arraybidimensionale . Gli indici vengono specificati come interi a 64 bit.
GetValue(Int64, Int64, Int64)	Ottiene il valore in corrispondenza della posizione specificata nell'Arraytridimensionale . Gli indici vengono specificati come interi a 64 bit.
GetValue(Int64[])	Ottiene il valore in corrispondenza della posizione specificata nel Arraymultidimensionale . Gli indici vengono specificati come matrice di interi a 64 bit.
IndexOf(Array, Object)	Cerca l'oggetto specificato e restituisce l'indice della prima occorrenza in una matrice unidimensionale.
IndexOf(Array, Object, Int32)	Cerca l'oggetto specificato in un intervallo di elementi di una matrice unidimensionale e restituisce l'indice della prima occorrenza. L'intervallo si estende da un indice specificato alla fine della matrice.
IndexOf(Array, Object, Int32, Int32)	Cerca l'oggetto specificato in un intervallo di elementi di una matrice unidimensionale e restituisce l'indice di ifs prima occorrenza. L'intervallo si estende da un indice specificato per un numero specificato di elementi.
IndexOf<T>(T[], T)	Cerca l'oggetto specificato e restituisce l'indice della prima occorrenza in una matrice unidimensionale.
IndexOf<T>(T[], T, Int32)	Cerca l'oggetto specificato in un intervallo di elementi di una matrice unidimensionale e restituisce l'indice della prima occorrenza. L'intervallo si estende da un indice specificato alla fine della matrice.
IndexOf<T>(T[], T, Int32, Int32)	Cerca l'oggetto specificato in un intervallo di elementi di una matrice unidimensionale e restituisce l'indice della prima occorrenza. L'intervallo si estende da un indice specificato per un numero specificato di elementi.
Initialize()	Inizializza ogni elemento del tipo valore Array chiamando il costruttore senza parametri del tipo valore.
LastIndexOf(Array, Object)	Cerca l'oggetto specificato e restituisce l'indice dell'ultima occorrenza all'interno dell'intero Arrayunidimensionale .
LastIndexOf(Array, Object, Int32)	Cerca l'oggetto specificato e restituisce l'indice dell'ultima occorrenza all'interno dell'intervallo di elementi nell'Array unidimensionale che si estende dal primo elemento all'indice specificato.
LastIndexOf(Array, Object, Int32, Int32)	Cerca l'oggetto specificato e restituisce l'indice dell'ultima occorrenza all'interno dell'intervallo di elementi nell'Array unidimensionale contenente il numero specificato di elementi e termina in corrispondenza dell'indice specificato.
LastIndexOf<T>(T[], T)	Cerca l'oggetto specificato e restituisce l'indice dell'ultima occorrenza all'interno dell'intero Array.
LastIndexOf<T>(T[], T, Int32)	Cerca l'oggetto specificato e restituisce l'indice dell'ultima occorrenza all'interno dell'intervallo di elementi nella Array che si estende dal primo elemento all'indice specificato.
LastIndexOf<T>(T[], T, Int32, Int32)	Cerca l'oggetto specificato e restituisce l'indice dell'ultima occorrenza all'interno dell'intervallo di elementi nella Array che contiene il numero specificato di elementi e termina in corrispondenza dell'indice specificato.
MemberwiseClone()	Crea una copia superficiale del Objectcorrente. (Ereditato da Object)
Resize<T>(T[], Int32)	Modifica il numero di elementi di una matrice unidimensionale alla nuova dimensione specificata.
Reverse(Array)	Inverte la sequenza degli elementi nell'intero Arrayunidimensionale.
Reverse(Array, Int32, Int32)	Inverte la sequenza di un subset degli elementi nel Arrayunidimensionale .
Reverse<T>(T[])	Inverte la sequenza degli elementi nella matrice generica unidimensionale.
Reverse<T>(T[], Int32, Int32)	Inverte la sequenza di un subset degli elementi nella matrice generica unidimensionale.
SetValue(Object, Int32)	Imposta un valore sull'elemento in corrispondenza della posizione specificata nell'Arrayunidimensionale . L'indice viene specificato come intero a 32 bit.
SetValue(Object, Int32, Int32)	Imposta un valore sull'elemento in corrispondenza della posizione specificata nella Arraybidimensionale . Gli indici vengono specificati come interi a 32 bit.
SetValue(Object, Int32, Int32, Int32)	Imposta un valore sull'elemento in corrispondenza della posizione specificata nell'Arraytridimensionale . Gli indici vengono specificati come interi a 32 bit.
SetValue(Object, Int32[])	Imposta un valore sull'elemento in corrispondenza della posizione specificata nel Arraymultidimensionale . Gli indici vengono specificati come matrice di interi a 32 bit.
SetValue(Object, Int64)	Imposta un valore sull'elemento in corrispondenza della posizione specificata nell'Arrayunidimensionale . L'indice viene specificato come intero a 64 bit.
SetValue(Object, Int64, Int64)	Imposta un valore sull'elemento in corrispondenza della posizione specificata nella Arraybidimensionale . Gli indici vengono specificati come interi a 64 bit.
SetValue(Object, Int64, Int64, Int64)	Imposta un valore sull'elemento in corrispondenza della posizione specificata nell'Arraytridimensionale . Gli indici vengono specificati come interi a 64 bit.
SetValue(Object, Int64[])	Imposta un valore sull'elemento in corrispondenza della posizione specificata nel Arraymultidimensionale . Gli indici vengono specificati come matrice di interi a 64 bit.
Sort(Array)	Ordina gli elementi in un intero Array unidimensionale usando l'implementazione IComparable di ogni elemento del Array.
Sort(Array, Array)	Ordina una coppia di oggetti Array unidimensionali (uno contiene le chiavi e l'altro contiene gli elementi corrispondenti) in base alle chiavi nel primo Array usando l'implementazione IComparable di ogni chiave.
Sort(Array, Array, IComparer)	Ordina una coppia di oggetti Array unidimensionali (uno contiene le chiavi e l'altro contiene gli elementi corrispondenti) in base alle chiavi nel primo Array utilizzando il IComparerspecificato.
Sort(Array, Array, Int32, Int32)	Ordina un intervallo di elementi in una coppia di oggetti Array unidimensionali (uno contiene le chiavi e l'altro contiene gli elementi corrispondenti) in base alle chiavi nel primo Array usando l'implementazione IComparable di ogni chiave.
Sort(Array, Array, Int32, Int32, IComparer)	Ordina un intervallo di elementi in una coppia di oggetti Array unidimensionali (uno contiene le chiavi e l'altro contiene gli elementi corrispondenti) in base alle chiavi nel primo Array utilizzando il IComparerspecificato.
Sort(Array, IComparer)	Ordina gli elementi in un Array unidimensionale utilizzando il IComparerspecificato.
Sort(Array, Int32, Int32)	Ordina gli elementi in un intervallo di elementi in un Array unidimensionale usando l'implementazione IComparable di ogni elemento del Array.
Sort(Array, Int32, Int32, IComparer)	Ordina gli elementi in un intervallo di elementi in un Array unidimensionale utilizzando il IComparerspecificato.
Sort<T>(T[])	Ordina gli elementi in un'intera Array usando l'implementazione dell'interfaccia generica IComparable<T> di ogni elemento del Array.
Sort<T>(T[], Comparison<T>)	Ordina gli elementi in un Array utilizzando il Comparison<T>specificato.
Sort<T>(T[], IComparer<T>)	Ordina gli elementi in un Array utilizzando l'interfaccia generica IComparer<T> specificata.
Sort<T>(T[], Int32, Int32)	Ordina gli elementi in un intervallo di elementi in un Array usando l'implementazione dell'interfaccia generica IComparable<T> di ogni elemento del Array.
Sort<T>(T[], Int32, Int32, IComparer<T>)	Ordina gli elementi in un intervallo di elementi in un Array utilizzando l'interfaccia IComparer<T> generica specificata.
Sort<TKey,TValue>(TKey[], TValue[])	Ordina una coppia di oggetti Array (uno contiene le chiavi e l'altro contiene gli elementi corrispondenti) in base alle chiavi nel primo Array usando l'implementazione dell'interfaccia generica IComparable<T> di ogni chiave.
Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>)	Ordina una coppia di oggetti Array (uno contiene le chiavi e l'altro contiene gli elementi corrispondenti) in base alle chiavi nel primo Array utilizzando l'interfaccia generica specificata IComparer<T>.
Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32)	Ordina un intervallo di elementi in una coppia di oggetti Array (uno contiene le chiavi e l'altro contiene gli elementi corrispondenti) in base alle chiavi nel primo Array usando l'implementazione dell'interfaccia generica IComparable<T> di ogni chiave.
Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>)	Ordina un intervallo di elementi in una coppia di oggetti Array (uno contiene le chiavi e l'altro contiene gli elementi corrispondenti) in base alle chiavi nel primo Array utilizzando l'interfaccia generica specificata IComparer<T>.
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)
TrueForAll<T>(T[], Predicate<T>)	Determina se ogni elemento della matrice corrisponde alle condizioni definite dal predicato specificato.

Implementazioni dell'interfaccia esplicita

ICollection.Count	Ottiene il numero di elementi contenuti nella Array.
IList.Add(Object)	La chiamata a questo metodo genera sempre un'eccezione NotSupportedException.
IList.Clear()	Rimuove tutti gli elementi dal IList.
IList.Contains(Object)	Determina se un elemento si trova nel IList.
IList.IndexOf(Object)	Determina l'indice di un elemento specifico nel IList.
IList.Insert(Int32, Object)	Inserisce un elemento nella IList in corrispondenza dell'indice specificato.
IList.Item[Int32]	Ottiene o imposta l'elemento in corrispondenza dell'indice specificato.
IList.Remove(Object)	Rimuove la prima occorrenza di un oggetto specifico dal IList.
IList.RemoveAt(Int32)	Rimuove l'elemento IList in corrispondenza dell'indice specificato.
IStructuralComparable.CompareTo(Object, IComparer)	Determina se l'oggetto raccolta corrente precede, si verifica nella stessa posizione di o segue un altro oggetto nell'ordinamento.
IStructuralEquatable.Equals(Object, IEqualityComparer)	Determina se un oggetto è uguale all'istanza corrente.
IStructuralEquatable.GetHashCode(IEqualityComparer)	Restituisce un codice hash per l'istanza corrente.

Metodi di estensione

Cast<TResult>(IEnumerable)	Esegue il cast degli elementi di un IEnumerable al tipo specificato.
OfType<TResult>(IEnumerable)	Filtra gli elementi di un IEnumerable in base a un tipo specificato.
AsParallel(IEnumerable)	Abilita la parallelizzazione di una query.
AsQueryable(IEnumerable)	Converte un IEnumerable in un IQueryable.

Thread safety

I membri statici pubblici (Shared in Visual Basic) di questo tipo sono thread-safe. Non è garantito che tutti i membri dell'istanza siano thread-safe.

Questa implementazione non fornisce un wrapper sincronizzato (thread-safe) per un Array; Tuttavia, le classi .NET basate su Array forniscono la propria versione sincronizzata della raccolta usando la proprietà SyncRoot.

L'enumerazione tramite una raccolta non è intrinsecamente una procedura thread-safe. Anche quando una raccolta viene sincronizzata, altri thread possono comunque modificare la raccolta, causando la generazione di un'eccezione da parte dell'enumeratore. Per garantire la thread safety durante l'enumerazione, è possibile bloccare la raccolta durante l'intera enumerazione o intercettare le eccezioni risultanti dalle modifiche apportate da altri thread.

Vedi anche

• Object
• Type
• esecuzione di operazioni di stringa Culture-Insensitive nelle matrici
• matrici (Guida per programmatori C#)
• matrici in F#
• matrici in Visual Basic