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.Provides methods for creating, manipulating, searching, and sorting arrays, thereby serving as the base class for all arrays in the common language runtime.

public ref class Array abstract : ICloneable, System::Collections::IList, System::Collections::IStructuralComparable, System::Collections::IStructuralEquatable
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public abstract class Array : ICloneable, System.Collections.IList, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable
type Array = class
    interface ICloneable
    interface ICollection
    interface IList
    interface IEnumerable
    interface IStructuralComparable
    interface IStructuralEquatable
Public MustInherit Class Array
Implements ICloneable, IList, IStructuralComparable, IStructuralEquatable
Ereditarietà
Array
Attributi
Implementazioni

Esempi

Nota

Alcuni degli esempi in C# in questo articolo vengono eseguiti nello strumento di esecuzione e playground per codice inline Try.NET.Some of the C# examples in this article run in the Try.NET inline code runner and playground. Quando è presente, selezionare il pulsante Esegui per eseguire un esempio in una finestra interattiva.When present, select the Run button to run an example in an interactive window. Dopo aver eseguito il codice, è possibile modificarlo ed eseguire il codice modificato selezionando di nuovo Esegui.Once you execute the code, you can modify it and run the modified code by selecting Run again. Il codice modificato viene eseguito nella finestra interattiva o, se la compilazione non riesce, la finestra interattiva visualizza tutti i messaggi di errore del compilatore C#.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

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.The following code example shows how Array.Copy copies elements between an array of type integer and an array of type 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 inizializzato un Array e ne vengono visualizzate le proprietà e i relativi elementi.The following code example creates and initializes an Array and displays its properties and its elements.

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 Int32.
Array myArr = Array.CreateInstance(typeof(Int32), 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.The Array class is not part of the System.Collections namespaces. Tuttavia, viene comunque considerata una raccolta perché è basata sull'interfaccia IList.However, it is still considered a collection because it is based on the IList interface.

La classe Array è la classe base per le implementazioni del linguaggio che supportano le matrici.The Array class is the base class for language implementations that support arrays. Tuttavia, solo il sistema e i compilatori possono derivare in modo esplicito dalla classe Array.However, only the system and compilers can derive explicitly from the Array class. Gli utenti devono usare i costrutti di matrice forniti dal linguaggio.Users should employ the array constructs provided by the language.

Un elemento è un valore in un Array.An element is a value in an Array. La lunghezza di un Array è il numero totale di elementi che può contenere.The length of an Array is the total number of elements it can contain. Il limite inferiore di un Array è l'indice del primo elemento.The lower bound of an Array is the index of its first element. Un Array può avere un limite inferiore, ma ha un limite inferiore pari a zero per impostazione predefinita.An Array can have any lower bound, but it has a lower bound of zero by default. Quando si crea un'istanza della classe Array usando CreateInstance, è possibile definire un limite inferiore diverso. Un Array multidimensionale può avere limiti diversi per ogni dimensione.A different lower bound can be defined when creating an instance of the Array class using CreateInstance.A multidimensional Array can have different bounds for each dimension. Una matrice può avere un massimo di 32 dimensioni.An array can have a maximum of 32 dimensions.

A differenza delle classi negli spazi dei nomi System.Collections, Array dispone di una capacità fissa.Unlike the classes in the System.Collections namespaces, Array has a fixed capacity. Per aumentare la capacità, è necessario creare un nuovo oggetto Array con la capacità necessaria, copiare gli elementi dall'oggetto Array precedente a quello nuovo ed eliminare il Arrayprecedente.To increase the capacity, you must create a new Array object with the required capacity, copy the elements from the old Array object to the new one, and delete the old Array.

La dimensione della matrice è limitata a un totale di 4 miliardi elementi e a un indice massimo di 0X7FEFFFFF in qualsiasi dimensione specificata (0X7FFFFFC7 per matrici di byte e matrici di strutture a byte singolo).The array size is limited to a total of 4 billion elements, and to a maximum index of 0X7FEFFFFF in any given dimension (0X7FFFFFC7 for byte arrays and arrays of single-byte structures).

Solo .NET Framework: Per impostazione predefinita, la dimensione massima di un Array è 2 gigabyte (GB)..NET Framework only: By default, the maximum size of an Array is 2 gigabytes (GB). In un ambiente a 64 bit, è possibile evitare la restrizione delle dimensioni impostando l'attributo enabled dell'elemento di configurazione gcAllowVeryLargeObjects su true nell'ambiente di Runtime.In a 64-bit environment, you can avoid the size restriction by setting the enabled attribute of the gcAllowVeryLargeObjects configuration element to true in the run-time environment.

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>.Single-dimensional arrays implement the System.Collections.Generic.IList<T>, System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyList<T> and System.Collections.Generic.IReadOnlyCollection<T> generic interfaces. 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.The implementations are provided to arrays at run time, and as a result, the generic interfaces do not appear in the declaration syntax for the Array class. Non sono inoltre disponibili argomenti di riferimento per i membri di interfaccia accessibili solo eseguendo il cast di una matrice al tipo di interfaccia generico (implementazioni esplicite dell'interfaccia).In addition, there are no reference topics for interface members that are accessible only by casting an array to the generic interface type (explicit interface implementations). L'aspetto fondamentale 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.The key thing to be aware of when you cast an array to one of these interfaces is that members which add, insert, or remove elements throw NotSupportedException.

gli oggetti Type forniscono informazioni sulle dichiarazioni di tipo matrice.Type objects provide information about array type declarations. Array oggetti con lo stesso tipo di matrice condividono lo stesso oggetto Type.Array objects with the same array type share the same Type object.

Type.IsArray e Type.GetElementType potrebbero non restituire i risultati previsti con Array perché se viene eseguito il cast di una matrice nel tipo Array, il risultato è un oggetto, non una matrice.Type.IsArray and Type.GetElementType might not return the expected results with Array because if an array is cast to the type Array, the result is an object, not an array. Ovvero typeof(System.Array).IsArray restituisce falsee typeof(System.Array).GetElementType restituisce null.That is, typeof(System.Array).IsArray returns false, and typeof(System.Array).GetElementType returns 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 del tipo.The Array.Copy method copies elements not only between arrays of the same type but also between standard arrays of different types; it handles type casting automatically.

Alcuni metodi, ad esempio CreateInstance, Copy, CopyTo, GetValuee SetValue, forniscono overload che accettano interi a 64 bit come parametri per adattarsi a matrici di capacità elevata.Some methods, such as CreateInstance, Copy, CopyTo, GetValue, and SetValue, provide overloads that accept 64-bit integers as parameters to accommodate large capacity arrays. LongLength e GetLongLength restituiscono interi a 64 bit che indicano la lunghezza della matrice.LongLength and GetLongLength return 64-bit integers indicating the length of the array.

Non è garantito l'ordinamento del Array.The Array is not guaranteed to be sorted. È necessario ordinare le Array prima di eseguire operazioni, ad esempio BinarySearch, che richiedono l'ordinamento dei Array.You must sort the Array prior to performing operations (such as BinarySearch) that require the Array to be sorted.

L'uso di un oggetto Array di puntatori nel codice nativo non è supportato e genererà un'NotSupportedException per diversi metodi.Using an Array object of pointers in native code is not supported and will throw a NotSupportedException for several methods.

Proprietà

IsFixedSize

Ottiene un valore che indica se Array ha dimensioni fisse.Gets a value indicating whether the Array has a fixed size.

IsReadOnly

Ottiene un valore che indica se Array è di sola lettura.Gets a value indicating whether the Array is read-only.

IsSynchronized

Ottiene un valore che indica se l'accesso a Array è sincronizzato (thread-safe).Gets a value indicating whether access to the Array is synchronized (thread safe).

Length

Ottiene il numero totale di elementi in tutte le dimensioni di Array.Gets the total number of elements in all the dimensions of the Array.

LongLength

Ottiene un integer a 64 bit che rappresenta il numero totale di elementi in tutte le dimensioni di Array.Gets a 64-bit integer that represents the total number of elements in all the dimensions of the Array.

Rank

Ottiene il rango (numero di dimensioni) dell'oggetto Array.Gets the rank (number of dimensions) of the Array. Ad esempio, una matrice unidimensionale restituisce 1, una matrice bidimensionale restituisce 2 e via di seguito.For example, a one-dimensional array returns 1, a two-dimensional array returns 2, and so on.

SyncRoot

Ottiene un oggetto che può essere usato per sincronizzare l'accesso a Array.Gets an object that can be used to synchronize access to the Array.

Metodi

AsReadOnly<T>(T[])

Restituisce un wrapper di sola lettura per la matrice specificata.Returns a read-only wrapper for the specified array.

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.Searches a range of elements in a one-dimensional sorted array for a value, using the IComparable interface implemented by each element of the array and by the specified value.

BinarySearch(Array, Int32, Int32, Object, IComparer)

Cerca un valore in un intervallo di elementi di una matrice unidimensionale ordinata mediante l'interfaccia IComparer specificata.Searches a range of elements in a one-dimensional sorted array for a value, using the specified IComparer interface.

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.Searches an entire one-dimensional sorted array for a specific element, using the IComparable interface implemented by each element of the array and by the specified object.

BinarySearch(Array, Object, IComparer)

Usando l'interfaccia IComparer specificata, effettua la ricerca di un valore all'interno di una matrice unidimensionale e ordinata.Searches an entire one-dimensional sorted array for a value using the specified IComparer interface.

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.Searches a range of elements in a one-dimensional sorted array for a value, using the IComparable<T> generic interface implemented by each element of the Array and by the specified value.

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.Searches a range of elements in a one-dimensional sorted array for a value, using the specified IComparer<T> generic interface.

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.Searches an entire one-dimensional sorted array for a specific element, using the IComparable<T> generic interface implemented by each element of the Array and by the specified object.

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.Searches an entire one-dimensional sorted array for a value using the specified IComparer<T> generic interface.

Clear(Array, Int32, Int32)

Imposta un intervallo di elementi in una matrice sul valore predefinito di ogni tipo di elemento.Sets a range of elements in an array to the default value of each element type.

Clone()

Crea una copia superficiale di Array.Creates a shallow copy of the 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.Copies a range of elements from an Array starting at the specified source index and pastes them to another Array starting at the specified destination index. Garantisce che tutte le modifiche vengano annullate se la copia non riesce completamente.Guarantees that all changes are undone if the copy does not succeed completely.

ConvertAll<TInput,TOutput>(TInput[], Converter<TInput,TOutput>)

Converte una matrice di un tipo in una matrice di un altro tipo.Converts an array of one type to an array of another type.

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.Copies a range of elements from an Array starting at the first element and pastes them into another Array starting at the first element. La lunghezza viene specificata come intero a 32 bit.The length is specified as a 32-bit integer.

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.Copies a range of elements from an Array starting at the first element and pastes them into another Array starting at the first element. La lunghezza viene specificata come intero a 64 bit.The length is specified as a 64-bit integer.

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.Copies a range of elements from an Array starting at the specified source index and pastes them to another Array starting at the specified destination index. La lunghezza e gli indici vengono specificati come interi a 32 bit.The length and the indexes are specified as 32-bit integers.

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.Copies a range of elements from an Array starting at the specified source index and pastes them to another Array starting at the specified destination index. La lunghezza e gli indici vengono specificati come interi a 64 bit.The length and the indexes are specified as 64-bit integers.

CopyTo(Array, Int32)

Copia tutti gli elementi dell'attuale matrice unidimensionale nella matrice unidimensionale specificata a partire dall'indice della matrice di destinazione indicato.Copies all the elements of the current one-dimensional array to the specified one-dimensional array starting at the specified destination array index. L'indice viene specificato come intero a 32 bit.The index is specified as a 32-bit integer.

CopyTo(Array, Int64)

Copia tutti gli elementi dell'attuale matrice unidimensionale nella matrice unidimensionale specificata a partire dall'indice della matrice di destinazione indicato.Copies all the elements of the current one-dimensional array to the specified one-dimensional array starting at the specified destination array index. L'indice viene specificato come intero a 64 bit.The index is specified as a 64-bit integer.

CreateInstance(Type, Int32)

Crea un oggetto Array unidimensionale dell'oggetto Type specificato e della lunghezza, con indice in base zero.Creates a one-dimensional Array of the specified Type and length, with zero-based indexing.

CreateInstance(Type, Int32, Int32)

Crea un oggetto Array bidimensionale dell'oggetto Type specificato e delle lunghezze delle dimensioni specificate, con indice in base zero.Creates a two-dimensional Array of the specified Type and dimension lengths, with zero-based indexing.

CreateInstance(Type, Int32, Int32, Int32)

Crea un oggetto Array tridimensionale dell'oggetto Type specificato e le lunghezze della dimensione, con indice in base zero.Creates a three-dimensional Array of the specified Type and dimension lengths, with zero-based indexing.

CreateInstance(Type, Int32[])

Crea un oggetto Array multidimensionale dell'oggetto Type specificato e delle lunghezze della dimensione, con indicizzazione in base zero.Creates a multidimensional Array of the specified Type and dimension lengths, with zero-based indexing. Le lunghezze vengono specificate in una matrice di interi a 32 bit.The dimension lengths are specified in an array of 32-bit integers.

CreateInstance(Type, Int32[], Int32[])

Crea una matrice Array multidimensionale con il valore Type e lunghezze della dimensione specificati, con i limiti inferiori specificati.Creates a multidimensional Array of the specified Type and dimension lengths, with the specified lower bounds.

CreateInstance(Type, Int64[])

Crea un oggetto Array multidimensionale dell'oggetto Type specificato e delle lunghezze della dimensione, con indicizzazione in base zero.Creates a multidimensional Array of the specified Type and dimension lengths, with zero-based indexing. Le lunghezze delle dimensioni vengono specificate in una matrice di interi a 64 bit.The dimension lengths are specified in an array of 64-bit integers.

Empty<T>()

Restituisce una matrice vuota.Returns an empty array.

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Ereditato da Object)
Exists<T>(T[], Predicate<T>)

Determina se la matrice indicata contiene elementi che soddisfano le condizioni definite nel predicato specificato.Determines whether the specified array contains elements that match the conditions defined by the specified predicate.

Fill<T>(T[], T)

Assegna value specificato di tipo T a ogni elemento di array specificato.Assigns the given value of type T to each element of the specified array.

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.Assigns the given value of type T to the elements of the specified array which are within the range of startIndex (inclusive) and the next count number of indices.

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.Searches for an element that matches the conditions defined by the specified predicate, and returns the first occurrence within the entire Array.

FindAll<T>(T[], Predicate<T>)

Recupera tutti gli elementi che soddisfano le condizioni definite nel predicato specificato.Retrieves all the elements that match the conditions defined by the specified predicate.

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.Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the Array that starts at the specified index and contains the specified number of elements.

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.Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the Array that extends from the specified index to the last element.

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.Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the entire 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.Searches for an element that matches the conditions defined by the specified predicate, and returns the last occurrence within the entire Array.

FindLastIndex<T>(T[], Int32, Int32, Predicate<T>)

Cerca un elemento che soddisfi le condizioni definite nel predicato specificato e restituisce l'indice in base zero dell'ultima occorrenza all'interno dell'intervallo di elementi dell'oggetto Array che contiene il numero indicato di elementi e termina in corrispondenza dell'indice specificato.Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the range of elements in the Array that contains the specified number of elements and ends at the specified index.

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.Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the range of elements in the Array that extends from the first element to the specified index.

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.Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the entire Array.

ForEach<T>(T[], Action<T>)

Esegue l'azione specificata su ciascun elemento della matrice indicata.Performs the specified action on each element of the specified array.

GetEnumerator()

Restituisce IEnumerator per Array.Returns an IEnumerator for the Array.

GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Ereditato da Object)
GetLength(Int32)

Ottiene un valore intero a 32 bit che rappresenta il numero di elementi nella dimensione specificata di Array.Gets a 32-bit integer that represents the number of elements in the specified dimension of the Array.

GetLongLength(Int32)

Ottiene un integer a 64 bit che rappresenta il numero di elementi nella dimensione specificata di Array.Gets a 64-bit integer that represents the number of elements in the specified dimension of the Array.

GetLowerBound(Int32)

Ottiene l'indice del primo elemento della dimensione specificata nella matrice.Gets the index of the first element of the specified dimension in the array.

GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Ereditato da Object)
GetUpperBound(Int32)

Ottiene l'indice dell'ultimo elemento della dimensione specificata nella matrice.Gets the index of the last element of the specified dimension in the array.

GetValue(Int32)

Ottiene il valore in corrispondenza della posizione specificata nell'oggetto Array unidimensionale.Gets the value at the specified position in the one-dimensional Array. L'indice viene specificato come intero a 32 bit.The index is specified as a 32-bit integer.

GetValue(Int32, Int32)

Ottiene il valore in corrispondenza della posizione specificata nell'oggetto Array bidimensionale.Gets the value at the specified position in the two-dimensional Array. Gli indici vengono specificati come valori interi a 32 bit.The indexes are specified as 32-bit integers.

GetValue(Int32, Int32, Int32)

Ottiene il valore in corrispondenza della posizione specificata nell'oggetto Array tridimensionale.Gets the value at the specified position in the three-dimensional Array. Gli indici vengono specificati come interi a 32 bit.The indexes are specified as 32-bit integers.

GetValue(Int32[])

Ottiene il valore in corrispondenza della posizione specificata nell'oggetto Array multidimensionale.Gets the value at the specified position in the multidimensional Array. Gli indici vengono specificati come una matrice di interi a 32 bit.The indexes are specified as an array of 32-bit integers.

GetValue(Int64)

Ottiene il valore in corrispondenza della posizione specificata nell'oggetto Array unidimensionale.Gets the value at the specified position in the one-dimensional Array. L'indice viene specificato come intero a 64 bit.The index is specified as a 64-bit integer.

GetValue(Int64, Int64)

Ottiene il valore in corrispondenza della posizione specificata nell'oggetto Array bidimensionale.Gets the value at the specified position in the two-dimensional Array. Gli indici vengono specificati come valori interi a 64 bit.The indexes are specified as 64-bit integers.

GetValue(Int64, Int64, Int64)

Ottiene il valore in corrispondenza della posizione specificata nell'oggetto Array tridimensionale.Gets the value at the specified position in the three-dimensional Array. Gli indici vengono specificati come valori interi a 64 bit.The indexes are specified as 64-bit integers.

GetValue(Int64[])

Ottiene il valore in corrispondenza della posizione specificata nell'oggetto Array multidimensionale.Gets the value at the specified position in the multidimensional Array. Gli indici vengono specificati come una matrice di valori interi a 64 bit.The indexes are specified as an array of 64-bit integers.

IndexOf(Array, Object)

Cerca l'oggetto specificato e restituisce l'indice della prima ricorrenza all'interno di una matrice unidimensionale.Searches for the specified object and returns the index of its first occurrence in a one-dimensional array.

IndexOf(Array, Object, Int32)

Cerca l'oggetto specificato in un intervallo di elementi di una matrice unidimensionale e restituisce l'indice della prima occorrenza.Searches for the specified object in a range of elements of a one-dimensional array, and returns the index of its first occurrence. L'intervallo si estende da un indice specificato fino alla fine della matrice.The range extends from a specified index to the end of the array.

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.Searches for the specified object in a range of elements of a one-dimensional array, and returns the index of ifs first occurrence. L'intervallo si estende da un indice specificato per un numero specificato di elementi.The range extends from a specified index for a specified number of elements.

IndexOf<T>(T[], T)

Cerca l'oggetto specificato e restituisce l'indice della prima ricorrenza all'interno di una matrice unidimensionale.Searches for the specified object and returns the index of its first occurrence in a one-dimensional array.

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.Searches for the specified object in a range of elements of a one dimensional array, and returns the index of its first occurrence. L'intervallo si estende da un indice specificato fino alla fine della matrice.The range extends from a specified index to the end of the array.

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.Searches for the specified object in a range of elements of a one-dimensional array, and returns the index of its first occurrence. L'intervallo si estende da un indice specificato per un numero specificato di elementi.The range extends from a specified index for a specified number of elements.

Initialize()

Inizializza ogni elemento del tipo valore Array tramite chiamate al costruttore senza parametri del tipo valore.Initializes every element of the value-type Array by calling the parameterless constructor of the value type.

LastIndexOf(Array, Object)

Cerca l'oggetto specificato e restituisce l'indice dell'ultima ricorrenza all'interno dell'oggetto Array unidimensionale intero.Searches for the specified object and returns the index of the last occurrence within the entire one-dimensional Array.

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.Searches for the specified object and returns the index of the last occurrence within the range of elements in the one-dimensional Array that extends from the first element to the specified index.

LastIndexOf(Array, Object, Int32, Int32)

Cerca l'oggetto specificato e restituisce l'indice dell'ultima occorrenza all'interno dell'intervallo di elementi dell'oggetto Array unidimensionale che contiene il numero specificato di elementi e termina in corrispondenza dell'indice specificato.Searches for the specified object and returns the index of the last occurrence within the range of elements in the one-dimensional Array that contains the specified number of elements and ends at the specified index.

LastIndexOf<T>(T[], T)

Cerca l'oggetto specificato e restituisce l'indice dell'ultima occorrenza all'interno dell'intera matrice Array.Searches for the specified object and returns the index of the last occurrence within the entire 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.Searches for the specified object and returns the index of the last occurrence within the range of elements in the Array that extends from the first element to the specified index.

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.Searches for the specified object and returns the index of the last occurrence within the range of elements in the Array that contains the specified number of elements and ends at the specified index.

MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
Resize<T>(T[], Int32)

Modifica il numero di elementi di una matrice unidimensionale in una nuova dimensione specificata.Changes the number of elements of a one-dimensional array to the specified new size.

Reverse(Array)

Inverte la sequenza degli elementi nell'oggetto Array unidimensionale.Reverses the sequence of the elements in the entire one-dimensional Array.

Reverse(Array, Int32, Int32)

Inverte la sequenza degli elementi in un intervallo di elementi dell'oggetto Array unidimensionale.Reverses the sequence of the elements in a range of elements in the one-dimensional Array.

Reverse<T>(T[])
Reverse<T>(T[], Int32, Int32)
SetValue(Object, Int32)

Ottiene il valore in corrispondenza della posizione specificata nell'oggetto Array unidimensionale.Sets a value to the element at the specified position in the one-dimensional Array. L'indice viene specificato come intero a 32 bit.The index is specified as a 32-bit integer.

SetValue(Object, Int32, Int32)

Imposta un valore sull'elemento in corrispondenza della posizione specificata nell'oggetto Array bidimensionale.Sets a value to the element at the specified position in the two-dimensional Array. Gli indici vengono specificati come interi a 32 bit.The indexes are specified as 32-bit integers.

SetValue(Object, Int32, Int32, Int32)

Imposta un valore sull'elemento in corrispondenza della posizione specificata nell'oggetto Array tridimensionale.Sets a value to the element at the specified position in the three-dimensional Array. Gli indici vengono specificati come interi a 32 bit.The indexes are specified as 32-bit integers.

SetValue(Object, Int32[])

Imposta il valore sull'elemento in corrispondenza della posizione specificata nell'oggetto Array multidimensionale.Sets a value to the element at the specified position in the multidimensional Array. Gli indici vengono specificati come una matrice di interi a 32 bit.The indexes are specified as an array of 32-bit integers.

SetValue(Object, Int64)

Imposta un valore sull'elemento in corrispondenza della posizione specificata nell'oggetto Array unidimensionale.Sets a value to the element at the specified position in the one-dimensional Array. L'indice viene specificato come intero a 64 bit.The index is specified as a 64-bit integer.

SetValue(Object, Int64, Int64)

Imposta un valore sull'elemento in corrispondenza della posizione specificata nell'oggetto Array bidimensionale.Sets a value to the element at the specified position in the two-dimensional Array. Gli indici vengono specificati come valori interi a 64 bit.The indexes are specified as 64-bit integers.

SetValue(Object, Int64, Int64, Int64)

Imposta un valore sull'elemento in corrispondenza della posizione specificata nell'oggetto Array tridimensionale.Sets a value to the element at the specified position in the three-dimensional Array. Gli indici vengono specificati come valori interi a 64 bit.The indexes are specified as 64-bit integers.

SetValue(Object, Int64[])

Imposta un valore sull'elemento in corrispondenza della posizione specificata nell'oggetto Array multidimensionale.Sets a value to the element at the specified position in the multidimensional Array. Gli indici vengono specificati come una matrice di valori interi a 64 bit.The indexes are specified as an array of 64-bit integers.

Sort(Array)

Ordina gli elementi di un'intera Array unidimensionale usando l'implementazione IComparable di ciascun elemento dell'oggetto Array.Sorts the elements in an entire one-dimensional Array using the IComparable implementation of each element of the 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.Sorts a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable implementation of each key.

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.Sorts a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified IComparer.

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.Sorts a range of elements in a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable implementation of each key.

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.Sorts a range of elements in a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified IComparer.

Sort(Array, IComparer)

Ordina gli elementi in un oggetto Array unidimensionale usando l'oggetto IComparer specificato.Sorts the elements in a one-dimensional Array using the specified IComparer.

Sort(Array, Int32, Int32)

Ordina un intervallo di elementi di un oggetto Array unidimensionale usando l'implementazione IComparable di ciascun elemento dell'oggetto Array.Sorts the elements in a range of elements in a one-dimensional Array using the IComparable implementation of each element of the Array.

Sort(Array, Int32, Int32, IComparer)

Ordina gli elementi in un intervallo di elementi di un oggetto Array unidimensionale usando l'oggetto IComparer specificato.Sorts the elements in a range of elements in a one-dimensional Array using the specified IComparer.

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.Sorts the elements in an entire Array using the IComparable<T> generic interface implementation of each element of the Array.

Sort<T>(T[], Comparison<T>)

Ordina gli elementi in un oggetto Array usando l'oggetto Comparison<T> specificato.Sorts the elements in an Array using the specified Comparison<T>.

Sort<T>(T[], IComparer<T>)

Ordina gli elementi in un oggetto Array usando l'interfaccia generica IComparer<T> specificata.Sorts the elements in an Array using the specified IComparer<T> generic interface.

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.Sorts the elements in a range of elements in an Array using the IComparable<T> generic interface implementation of each element of the Array.

Sort<T>(T[], Int32, Int32, IComparer<T>)

Ordina un intervallo di elementi di un oggetto Array usando l'interfaccia generica IComparer<T> specificata.Sorts the elements in a range of elements in an Array using the specified IComparer<T> generic interface.

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.Sorts a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable<T> generic interface implementation of each key.

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.Sorts a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified IComparer<T> generic interface.

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.Sorts a range of elements in a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable<T> generic interface implementation of each key.

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.Sorts a range of elements in a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified IComparer<T> generic interface.

ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Ereditato da Object)
TrueForAll<T>(T[], Predicate<T>)

Determina se ogni elemento della matrice soddisfa le condizioni definite dal predicato specificato.Determines whether every element in the array matches the conditions defined by the specified predicate.

Implementazioni dell'interfaccia esplicita

ICollection.Count

Ottiene il numero di elementi contenuti in Array.Gets the number of elements contained in the Array.

ICollection.IsSynchronized

Ottiene un valore che indica se l'accesso a Array è sincronizzato (thread-safe).Gets a value that indicates whether access to the Array is synchronized (thread safe).

ICollection.SyncRoot

Ottiene un oggetto che può essere usato per sincronizzare l'accesso a Array.Gets an object that can be used to synchronize access to the Array.

IList.Add(Object)

La chiamata di questo metodo genera sempre un'eccezione NotSupportedException.Calling this method always throws a NotSupportedException exception.

IList.Clear()

Rimuove tutti gli elementi da IList.Removes all items from the IList.

IList.Contains(Object)

Determina se un elemento è incluso in IList.Determines whether an element is in the IList.

IList.IndexOf(Object)

Determina l'indice di un elemento specifico in IList.Determines the index of a specific item in the IList.

IList.Insert(Int32, Object)

Inserisce un elemento in IList in corrispondenza dell'indice specificato.Inserts an item to the IList at the specified index.

IList.IsFixedSize

Ottiene un valore che indica se le dimensioni dell'oggetto Array sono fisse.Gets a value that indicates whether the Array has a fixed size.

IList.IsReadOnly

Ottiene un valore che indica se Array è di sola lettura.Gets a value that indicates whether the Array is read-only.

IList.Item[Int32]

Ottiene o imposta l'elemento in corrispondenza dell'indice specificato.Gets or sets the element at the specified index.

IList.Remove(Object)

Rimuove la prima occorrenza di un oggetto specifico da IList.Removes the first occurrence of a specific object from the IList.

IList.RemoveAt(Int32)

Rimuove l'elemento IList in corrispondenza dell'indice specificato.Removes the IList item at the specified index.

IStructuralComparable.CompareTo(Object, IComparer)

Determina se l'oggetto raccolta corrente precede, è nella stessa posizione o segue un altro oggetto nell'ordinamento.Determines whether the current collection object precedes, occurs in the same position as, or follows another object in the sort order.

IStructuralEquatable.Equals(Object, IEqualityComparer)

Determina se un oggetto è uguale all'istanza corrente.Determines whether an object is equal to the current instance.

IStructuralEquatable.GetHashCode(IEqualityComparer)

Restituisce un codice hash per l'istanza corrente.Returns a hash code for the current instance.

Metodi di estensione

Cast<TResult>(IEnumerable)

Esegue il cast degli elementi di un oggetto IEnumerable nel tipo specificato.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filtra gli elementi di un oggetto IEnumerable in base a un tipo specificato.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Consente la parallelizzazione di una query.Enables parallelization of a query.

AsQueryable(IEnumerable)

Converte un oggetto IEnumerable in un oggetto IQueryable.Converts an IEnumerable to an IQueryable.

Si applica a

Thread safety

I membri statici pubblici (Shared in Visual Basic) di questo tipo sono thread-safe.Public static (Shared in Visual Basic) members of this type are thread safe. I membri di istanza non sono garantiti come thread-safe.Any instance members are not guaranteed to be thread safe.

Questa implementazione non fornisce un wrapper sincronizzato (thread-safe) per un Array; Tuttavia, .NET Framework classi basate su Array forniscono una propria versione sincronizzata della raccolta usando la proprietà SyncRoot.This implementation does not provide a synchronized (thread safe) wrapper for an Array; however, .NET Framework classes based on Array provide their own synchronized version of the collection using the SyncRoot property.

L'enumerazione di una raccolta non è di per sé una procedura thread-safe.Enumerating through a collection is intrinsically not a thread-safe procedure. Anche se una raccolta è sincronizzata, è possibile che venga modificata da altri thread, con conseguente generazione di un'eccezione da parte dell'enumeratore.Even when a collection is synchronized, other threads can still modify the collection, which causes the enumerator to throw an exception. 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.To guarantee thread safety during enumeration, you can either lock the collection during the entire enumeration or catch the exceptions resulting from changes made by other threads.

Vedi anche