Array Classe

Riferimento

Definizione

Spazio dei nomi:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Fornisce metodi per creare, manipolare, ordinare ed eseguire ricerche all'interno di matrici, diventando così la classe base per tutte le matrici in Common Language Runtime.

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

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

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

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

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

[System.Serializable]
public abstract class Array : ICloneable, System.Collections.IList

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class Array : ICloneable, System.Collections.IList

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
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

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

[<System.Serializable>]
type Array = class
    interface ICloneable
    interface IList
    interface ICollection
    interface IEnumerable

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Array = class
    interface ICloneable
    interface IList
    interface ICollection
    interface IEnumerable

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Array = class
    interface ICloneable
    interface IList
    interface ICollection
    interface IEnumerable
    interface IStructuralComparable
    interface IStructuralEquatable

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

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Array = class
    interface ICloneable
    interface ICollection
    interface IList
    interface IEnumerable
    interface IStructuralComparable
    interface IStructuralEquatable

Public MustInherit Class Array
Implements IList, IStructuralComparable, IStructuralEquatable

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

Public MustInherit Class Array
Implements ICloneable, IList

Ereditarietà: Object
Array

Attributi: SerializableAttribute ComVisibleAttribute

Implementazioni: ICollection IEnumerable IList IStructuralComparable IStructuralEquatable ICloneable

Esempio

Nell'esempio di codice seguente viene illustrato come Array.Copy copiare 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

L'esempio di codice seguente crea e inizializza un Array oggetto e visualizza 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 Array classe non fa parte degli System.Collections spazi dei nomi. Tuttavia, è ancora considerato una raccolta perché si basa sull'interfaccia IList .

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

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

A differenza delle classi negli System.Collections spazi dei nomi, Array ha una capacità fissa. Per aumentare la capacità, è necessario creare un nuovo Array oggetto con la capacità necessaria, copiare gli elementi dall'oggetto precedente Array 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 qualsiasi dimensione specificata (0X7FFFFFC7 per matrici di byte e matrici di strutture a byte singolo).

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

Le matrici a dimensione singola implementano le System.Collections.Generic.IList<T>interfacce generiche , System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>System.Collections.Generic.IReadOnlyList<T> e System.Collections.Generic.IReadOnlyCollection<T> . Le implementazioni vengono fornite alle matrici in fase di esecuzione e, di conseguenza, le interfacce generiche non vengono visualizzate nella sintassi della dichiarazione per la Array classe. 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'elemento chiave da tenere presente quando si esegue il cast di una matrice a una di queste interfacce è che i membri che aggiungono, inseriscono o rimuovino elementi generano NotSupportedException.

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

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

Il metodo copia gli elementi non solo tra matrici dello stesso tipo, ma anche tra matrici standard di tipi diversi. Gestisce Array.Copy 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 ospitare matrici di capacità di grandi dimensioni. LongLength e GetLongLength restituisce numeri interi a 64 bit che indicano la lunghezza della matrice.

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

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

Proprietà

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

Metodi

AsReadOnly<T>(T[])	Restituisce un wrapper di sola lettura per la matrice specificata.
BinarySearch(Array, Int32, Int32, Object)	Cerca un valore in un intervallo di elementi di una matrice unidimensionale ordinata, usando l'interfaccia IComparable implementata da ogni elemento della matrice e dal valore specificato.
BinarySearch(Array, Int32, Int32, Object, IComparer)	Cerca un valore in un intervallo di elementi di una matrice unidimensionale ordinata mediante l'interfaccia IComparer specificata.
BinarySearch(Array, Object)	Cerca un elemento specifico in un'intera raccolta unidimensionale ordinata, usando l'interfaccia IComparable implementata da ogni elemento della matrice e dall'oggetto specificato.
BinarySearch(Array, Object, IComparer)	Usando l'interfaccia IComparer specificata, effettua la ricerca di un valore all'interno di una matrice unidimensionale e ordinata.
BinarySearch<T>(T[], Int32, Int32, T)	Cerca un valore in un intervallo di elementi di una matrice unidimensionale ordinata, usando l'interfaccia generica IComparable<T> implementata da ogni elemento dell'oggetto Array e dal valore specificato.
BinarySearch<T>(T[], Int32, Int32, T, IComparer<T>)	Cerca un valore in un intervallo di elementi di una matrice unidimensionale ordinata mediante l'interfaccia generica IComparer<T> specificata.
BinarySearch<T>(T[], T)	Effettua una ricerca in un'intera matrice unidimensionale ordinata per un elemento specifico, usando l'interfaccia generica IComparable<T> implementata da ogni elemento di Array e dall'oggetto specificato.
BinarySearch<T>(T[], T, IComparer<T>)	Mediante l'interfaccia generica IComparer<T> specificata, esegue la ricerca di un valore all'interno di una matrice unidimensionale e ordinata.
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 di Array.
ConstrainedCopy(Array, Int32, Array, Int32, Int32)	Copia un intervallo di elementi da un oggetto Array a partire dall'indice di origine specificato e lo incolla in un altro oggetto 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 oggetto Array a partire dal primo elemento e lo incolla in un altro oggetto 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 oggetto Array a partire dal primo elemento e lo incolla in un altro oggetto 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 oggetto Array a partire dall'indice di origine specificato e lo incolla in un altro oggetto 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 oggetto Array a partire dall'indice di origine specificato e lo incolla in un altro oggetto 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 dell'attuale matrice unidimensionale nella matrice unidimensionale specificata a partire dall'indice della matrice di destinazione indicato. L'indice viene specificato come intero a 32 bit.
CopyTo(Array, Int64)	Copia tutti gli elementi dell'attuale matrice unidimensionale nella matrice unidimensionale specificata a partire dall'indice della matrice di destinazione indicato. L'indice viene specificato come intero a 64 bit.
CreateInstance(Type, Int32)	Crea un oggetto Array unidimensionale dell'oggetto Type specificato e della lunghezza, con indice in base zero.
CreateInstance(Type, Int32, Int32)	Crea un oggetto Array bidimensionale dell'oggetto Type specificato e delle lunghezze delle dimensioni specificate, con indice in base zero.
CreateInstance(Type, Int32, Int32, Int32)	Crea un oggetto Array tridimensionale dell'oggetto Type specificato e le lunghezze della dimensione, con indice in base zero.
CreateInstance(Type, Int32[])	Crea un oggetto Array multidimensionale dell'oggetto Type specificato e delle lunghezze della dimensione, con indicizzazione in base zero. Le lunghezze vengono specificate in una matrice di interi a 32 bit.
CreateInstance(Type, Int32[], Int32[])	Crea una matrice Array multidimensionale con il valore Type e lunghezze della dimensione specificati, con i limiti inferiori specificati.
CreateInstance(Type, Int64[])	Crea un oggetto Array multidimensionale dell'oggetto Type specificato e delle lunghezze della dimensione, 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 indicata contiene elementi che soddisfano le condizioni definite nel predicato specificato.
Fill<T>(T[], T)	Assegna `value` specificato di tipo `T` a ogni elemento di `array` specificato.
Fill<T>(T[], T, Int32, Int32)	Assegna `value` specificato di tipo `T` agli elementi di `array` specificato che sono compresi nell'intervallo tra `startIndex` (incluso) e il numero `count` successivo di indici.
Find<T>(T[], Predicate<T>)	Cerca un elemento che soddisfi le condizioni definite nel predicato specificato e restituisce la prima occorrenza all'interno dell'intero oggetto Array.
FindAll<T>(T[], Predicate<T>)	Recupera tutti gli elementi che soddisfano le condizioni definite nel predicato specificato.
FindIndex<T>(T[], Int32, Int32, Predicate<T>)	Cerca un elemento che soddisfi le condizioni definite dal predicato specificato e restituisce l'indice in base zero della prima occorrenza all'interno dell'intervallo di elementi nell'oggetto Array che inizia dall'indice specificato e contiene il numero indicato di elementi.
FindIndex<T>(T[], Int32, Predicate<T>)	Cerca un elemento che soddisfi le condizioni definite dal predicato specificato e restituisce l'indice in base zero della prima occorrenza all'interno dell'intervallo di elementi nell'oggetto Array compreso tra l'indice specificato e l'ultimo elemento.
FindIndex<T>(T[], Predicate<T>)	Cerca un elemento che corrisponda alle condizioni definite dal predicato specificato e restituisce l'indice in base zero della prima occorrenza all'interno di Array.
FindLast<T>(T[], Predicate<T>)	Cerca un elemento che soddisfi le condizioni definite nel predicato specificato e restituisce l'ultima occorrenza all'interno dell'intero oggetto Array.
FindLastIndex<T>(T[], Int32, Int32, Predicate<T>)	Cerca un elemento che soddisfi le condizioni definite dal predicato specificato e restituisce l'indice in base zero dell'ultima occorrenza all'interno dell'intervallo di elementi in Array che contiene il numero indicato di elementi e termina in corrispondenza dell'indice specificato.
FindLastIndex<T>(T[], Int32, Predicate<T>)	Cerca un elemento che soddisfi le condizioni definite dal predicato specificato e restituisce l'indice in base zero dell'ultima occorrenza all'interno dell'intervallo di elementi in Array compreso tra il primo elemento e l'indice specificato.
FindLastIndex<T>(T[], Predicate<T>)	Cerca un elemento che soddisfi le condizioni definite dal predicato specificato e restituisce l'indice in base zero dell'ultima occorrenza all'interno dell'intero oggetto Array.
ForEach<T>(T[], Action<T>)	Esegue l'azione specificata su ciascun elemento della matrice indicata.
GetEnumerator()	Restituisce IEnumerator per Array.
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetLength(Int32)	Ottiene un intero a 32 bit che rappresenta il numero di elementi nella dimensione specificata dell'oggetto Array.
GetLongLength(Int32)	Ottiene un integer a 64 bit che rappresenta il numero di elementi nella dimensione specificata di Array.
GetLowerBound(Int32)	Ottiene l'indice del primo elemento della dimensione specificata nella matrice.
GetType()	Ottiene l'oggetto 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'oggetto Array unidimensionale. L'indice viene specificato come intero a 32 bit.
GetValue(Int32, Int32)	Ottiene il valore in corrispondenza della posizione specificata nell'oggetto Array bidimensionale. Gli indici vengono specificati come interi a 32 bit.
GetValue(Int32, Int32, Int32)	Ottiene il valore in corrispondenza della posizione specificata nell'oggetto Array tridimensionale. Gli indici vengono specificati come interi a 32 bit.
GetValue(Int32[])	Ottiene il valore in corrispondenza della posizione specificata nell'oggetto Array multidimensionale. Gli indici vengono specificati come una matrice di interi a 32 bit.
GetValue(Int64)	Ottiene il valore in corrispondenza della posizione specificata nell'oggetto Array unidimensionale. L'indice viene specificato come intero a 64 bit.
GetValue(Int64, Int64)	Ottiene il valore in corrispondenza della posizione specificata nell'oggetto Array bidimensionale. Gli indici vengono specificati come interi a 64 bit.
GetValue(Int64, Int64, Int64)	Ottiene il valore in corrispondenza della posizione specificata nell'oggetto Array tridimensionale. Gli indici vengono specificati come interi a 64 bit.
GetValue(Int64[])	Ottiene il valore in corrispondenza della posizione specificata nell'oggetto Array multidimensionale. Gli indici vengono specificati come una matrice di valori interi a 64 bit.
IndexOf(Array, Object)	Cerca l'oggetto specificato e restituisce l'indice della prima ricorrenza all'interno di 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 fino alla fine della matrice.
IndexOf(Array, Object, Int32, Int32)	Cerca l'oggetto specificato e restituisce l'indice della prima occorrenza in un intervallo di elementi di una matrice unidimensionale. 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 ricorrenza all'interno di 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 fino 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 tramite chiamate al costruttore senza parametri del tipo valore.
LastIndexOf(Array, Object)	Cerca l'oggetto specificato e restituisce l'indice dell'ultima occorrenza all'interno dell'oggetto Array unidimensionale intero.
LastIndexOf(Array, Object, Int32)	Cerca l'oggetto specificato e restituisce l'indice dell'ultima occorrenza all'interno dell'intervallo di elementi dell'oggetto Array unidimensionale compreso tra il primo elemento e l'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'oggetto Array unidimensionale che contiene il numero di elementi specificato 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 oggetto Array.
LastIndexOf<T>(T[], T, Int32)	Cerca l'oggetto specificato e restituisce l'indice dell'ultima occorrenza all'interno dell'intervallo di elementi dell'oggetto Array compreso tra il primo elemento e l'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 dell'oggetto Array che contiene il numero specificato di elementi e termina in corrispondenza dell'indice specificato.
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
Resize<T>(T[], Int32)	Modifica il numero di elementi di una matrice unidimensionale in una nuova dimensione specificata.
Reverse(Array)	Inverte la sequenza degli elementi nell'oggetto Array unidimensionale.
Reverse(Array, Int32, Int32)	Inverte la sequenza di un sottoinsieme di elementi nell'oggetto Array unidimensionale.
Reverse<T>(T[])	Inverte la sequenza degli elementi nella matrice generica unidimensionale.
Reverse<T>(T[], Int32, Int32)	Inverte la sequenza di un sottoinsieme di elementi nella matrice generica unidimensionale.
SetValue(Object, Int32)	Imposta un valore sull'elemento in corrispondenza della posizione specificata nell'oggetto Array unidimensionale. L'indice viene specificato come intero a 32 bit.
SetValue(Object, Int32, Int32)	Imposta un valore sull'elemento in corrispondenza della posizione specificata nell'oggetto Array bidimensionale. 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'oggetto Array tridimensionale. Gli indici vengono specificati come interi a 32 bit.
SetValue(Object, Int32[])	Imposta un valore sull'elemento in corrispondenza della posizione specificata nell'oggetto Array multidimensionale. Gli indici vengono specificati come una matrice di interi a 32 bit.
SetValue(Object, Int64)	Imposta un valore sull'elemento in corrispondenza della posizione specificata nell'oggetto Array unidimensionale. L'indice viene specificato come intero a 64 bit.
SetValue(Object, Int64, Int64)	Imposta un valore sull'elemento in corrispondenza della posizione specificata nell'oggetto Array bidimensionale. 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'oggetto Array tridimensionale. Gli indici vengono specificati come interi a 64 bit.
SetValue(Object, Int64[])	Imposta un valore sull'elemento in corrispondenza della posizione specificata nell'oggetto Array multidimensionale. Gli indici vengono specificati come una matrice di valori interi a 64 bit.
Sort(Array)	Ordina gli elementi di un'intera Array unidimensionale usando l'implementazione IComparable di ciascun elemento dell'oggetto Array.
Sort(Array, Array)	Ordina una coppia di oggetti Array unidimensionali (uno contenente le chiavi e l'altro contenente gli elementi corrispondenti) in base alle chiavi del primo oggetto Array usando l'implementazione di IComparable di ogni chiave.
Sort(Array, Array, IComparer)	Ordina una coppia di oggetti Array unidimensionali (uno contenente le chiavi e l'altro contenente gli elementi corrispondenti) in base alle chiavi del primo oggetto Array usando l'interfaccia IComparer specificata.
Sort(Array, Array, Int32, Int32)	Ordina un intervallo di elementi in una coppia di oggetti Array unidimensionali (uno contenente le chiavi e l'altro gli elementi corrispondenti) in base alle chiavi nel primo oggetto Array usando l'implementazione di IComparable di ogni chiave.
Sort(Array, Array, Int32, Int32, IComparer)	Ordina un intervallo di elementi in una coppia di oggetti Array unidimensionali (uno contenente le chiavi e l'altro contenente gli elementi corrispondenti) in base alle chiavi nel primo oggetto Array usando l'interfaccia IComparer specificata.
Sort(Array, IComparer)	Ordina gli elementi in un oggetto Array unidimensionale usando l'oggetto IComparer specificato.
Sort(Array, Int32, Int32)	Ordina un intervallo di elementi di un oggetto Array unidimensionale usando l'implementazione IComparable di ciascun elemento dell'oggetto Array.
Sort(Array, Int32, Int32, IComparer)	Ordina gli elementi in un intervallo di elementi di un oggetto Array unidimensionale usando l'oggetto IComparer specificato.
Sort<T>(T[])	Ordina gli elementi di un intero oggetto Array usando l'implementazione dell'interfaccia generica IComparable<T> di ogni elemento dell'oggetto Array.
Sort<T>(T[], Comparison<T>)	Ordina gli elementi in un oggetto Array usando l'oggetto Comparison<T> specificato.
Sort<T>(T[], IComparer<T>)	Ordina gli elementi in un oggetto Array usando l'interfaccia generica IComparer<T> specificata.
Sort<T>(T[], Int32, Int32)	Ordina un intervallo di elementi di un oggetto Array usando l'implementazione dell'interfaccia generica IComparable<T> di ciascun elemento dell'oggetto Array.
Sort<T>(T[], Int32, Int32, IComparer<T>)	Ordina un intervallo di elementi di un oggetto Array usando l'interfaccia generica IComparer<T> specificata.
Sort<TKey,TValue>(TKey[], TValue[])	Ordina una coppia di oggetti Array (uno contenente le chiavi e l'altro contenente gli elementi corrispondenti) in base alle chiavi del primo oggetto 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 contenente le chiavi e l'altro contenente gli elementi corrispondenti) in base alle chiavi nel primo oggetto Array usando l'interfaccia generica IComparer<T> specificata.
Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32)	Ordina un intervallo di elementi in una coppia di oggetti Array (uno contenente le chiavi e l'altro contenente gli elementi corrispondenti) in base alle chiavi nel primo oggetto Array usando l'implementazione dell'interfaccia generica IComparable<T> di ciascuna chiave.
Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>)	Ordina un intervallo di elementi in una coppia di oggetti Array (uno contenente le chiavi e l'altro contenente gli elementi corrispondenti) in base alle chiavi nel primo oggetto Array usando l'interfaccia generica IComparer<T> specificata.
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)
TrueForAll<T>(T[], Predicate<T>)	Determina se ogni elemento della matrice soddisfa le condizioni definite dal predicato specificato.

Implementazioni dell'interfaccia esplicita

ICollection.Count	Ottiene il numero di elementi contenuti in Array.
ICollection.IsSynchronized	Ottiene un valore che indica se l'accesso a Array è sincronizzato (thread-safe).
ICollection.SyncRoot	Ottiene un oggetto che può essere usato per sincronizzare l'accesso a Array.
IList.Add(Object)	La chiamata di questo metodo genera sempre un'eccezione NotSupportedException.
IList.Clear()	Rimuove tutti gli elementi da IList.
IList.Contains(Object)	Determina se un elemento è incluso in IList.
IList.IndexOf(Object)	Determina l'indice di un elemento specifico in IList.
IList.Insert(Int32, Object)	Inserisce un elemento in IList in corrispondenza dell'indice specificato.
IList.IsFixedSize	Ottiene un valore che indica se le dimensioni dell'oggetto Array sono fisse.
IList.IsReadOnly	Ottiene un valore che indica se Array è di sola lettura.
IList.Item[Int32]	Ottiene o imposta l'elemento in corrispondenza dell'indice specificato.
IList.Remove(Object)	Rimuove la prima occorrenza di un oggetto specifico da IList.
IList.RemoveAt(Int32)	Rimuove l'elemento IList in corrispondenza dell'indice specificato.
IStructuralComparable.CompareTo(Object, IComparer)	Determina se l'oggetto raccolta corrente precede, è nella stessa posizione 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 oggetto IEnumerable nel tipo specificato.
OfType<TResult>(IEnumerable)	Filtra gli elementi di un oggetto IEnumerable in base a un tipo specificato.
AsParallel(IEnumerable)	Consente la parallelizzazione di una query.
AsQueryable(IEnumerable)	Converte un oggetto IEnumerable in un oggetto IQueryable.

Si applica a

Thread safety

I membri statici pubblici (Sharedin Visual Basic) di questo tipo sono thread safe. Non è invece garantita la sicurezza dei membri dell'istanza.

Questa implementazione non fornisce un wrapper sincronizzato (thread safe) per un Arrayoggetto . Tuttavia, le classi .NET in base Array a specificare la propria versione sincronizzata della raccolta usando la SyncRoot proprietà .

L'enumerazione di una raccolta non è di per sé una procedura thread-safe. Anche se una raccolta è sincronizzata, è possibile che venga modificata da altri thread, con conseguente generazione di un'eccezione da parte dell'enumeratore. Per garantire la protezione dei thread durante l'enumerazione, è possibile bloccare la raccolta per l'intera enumerazione oppure intercettare le eccezioni determinate dalle modifiche apportate da altri thread.