Array Classe

Definizione

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à
Array
Attributi
Implementazioni

Esempio

Nell'esempio di codice seguente viene illustrato come copiare gli elementi tra una matrice di tipo Array.Copy 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
*/
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 Array inizializzato un oggetto e ne vengono visualizzate le 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
 */
// 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 spazi dei nomi System.Collections . Tuttavia, è ancora considerata una raccolta perché è basata IList sull'interfaccia .

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

Un elemento è un valore in un Array oggetto . 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 oggetto può avere qualsiasi 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 Array classe usando CreateInstance . Una dimensione Array multidimensionale 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 , ha una capacità Array fissa. Per aumentare la capacità, è necessario creare un nuovo oggetto con la capacità necessaria, copiare gli elementi dall'oggetto precedente a quello nuovo Array ed eliminare il vecchio Array 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).

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

Le matrici unidimensionali implementano le interfacce System.Collections.Generic.IList<T> System.Collections.Generic.ICollection<T> System.Collections.Generic.IEnumerable<T> generiche , , 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 di dichiarazione per la Array classe. Non sono inoltre disponibili argomenti di riferimento per i membri di interfaccia accessibili solo eseguendo il cast di una matrice al tipo di interfaccia generica (implementazioni esplicite dell'interfaccia). L'aspetto chiave 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 Gli oggetti forniscono informazioni sulle dichiarazioni di tipo matrice. Array Gli oggetti con lo stesso tipo di matrice condividono lo Type stesso oggetto.

Type.IsArray e potrebbero non restituire i risultati previsti con perché se si esegue il cast di una matrice al tipo , il risultato è un Type.GetElementType oggetto e non una Array Array matrice. In altri, typeof(System.Array).IsArray restituisce false e restituisce typeof(System.Array).GetElementType null .

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

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

Non Array è garantito che l'oggetto sia ordinato. È necessario ordinare prima di eseguire operazioni ( ad esempio ) che Array BinarySearch richiedono Array l'ordinamento di .

ArrayL'uso di un oggetto di puntatori nel codice nativo non è supportato e genererà un'eccezione per diversi NotSupportedException 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 Shared statici pubblici (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 oggetto . Tuttavia, le classi .NET basate su forniscono la propria versione sincronizzata della raccolta Array Array usando la proprietà SyncRoot .

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.

Vedi anche