Array Classe

Définition

Espace de noms:

System

Assembly:

System.Runtime.dll

Source:

Array.cs

Fournit des méthodes pour créer, manipuler, rechercher et trier des tableaux, servant ainsi de classe de base pour tous les tableaux du Common Language Runtime.

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

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

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

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

Héritage

Object

Array

Implémente

ICollection IEnumerable IList IStructuralComparable IStructuralEquatable ICloneable

Exemples

L’exemple de code suivant montre comment Array.Copy copie des éléments entre un tableau d’entiers de type et un tableau de 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
*/

open System

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

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

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

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

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

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

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


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

using System;
public class SamplesArray
{

    public static void Main()
    {

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

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

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

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

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

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

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

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

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

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

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

Public Class SamplesArray

    Public Shared Sub Main()

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

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

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

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

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

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

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

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

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

L’exemple de code suivant crée et initialise une Array et affiche ses propriétés et ses éléments.

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

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

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

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

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

   Console::WriteLine();
}

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

open System

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

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

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

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

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

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

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

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

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

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

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

Public Class SamplesArray2

    Public Shared Sub Main()

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

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

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

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

Remarques

La classe Array ne fait pas partie des espaces de noms System.Collections. Toutefois, il est toujours considéré comme une collection, car elle est basée sur l’interface IList.

La classe Array est la classe de base pour les implémentations de langage qui prennent en charge les tableaux. Toutefois, seul le système et les compilateurs peuvent dériver explicitement de la classe Array. Les utilisateurs doivent utiliser les constructions de tableau fournies par la langue.

Un élément est une valeur dans un Array. La longueur d’une Array correspond au nombre total d’éléments qu’il peut contenir. La limite inférieure d’un Array est l’index de son premier élément. Une Array peut avoir n’importe quelle limite inférieure, mais elle a une limite inférieure de zéro par défaut. Une limite inférieure différente peut être définie lors de la création d’une instance de la classe Array à l’aide de CreateInstance. Un Array multidimensionnel peut avoir des limites différentes pour chaque dimension. Un tableau peut avoir un maximum de 32 dimensions.

Contrairement aux classes des espaces de noms System.Collections, Array a une capacité fixe. Pour augmenter la capacité, vous devez créer un objet Array avec la capacité requise, copier les éléments de l’ancien objet Array vers le nouveau et supprimer l’ancien Array.

La taille du tableau est limitée à un total de 4 milliards d’éléments et à un index maximal de 0X7FEFFFFF dans n’importe quelle dimension donnée (0X7FFFFFC7 pour les tableaux d’octets et les tableaux de structures à octet unique).

.NET Framework uniquement : Par défaut, la taille maximale d’un Array est de 2 gigaoctets (Go). Dans un environnement 64 bits, vous pouvez éviter la restriction de taille en définissant l’attribut enabled du gcAllowVeryLargeObjects élément de configuration sur true dans l’environnement d’exécution.

Les tableaux unidimensionnels implémentent les interfaces génériques System.Collections.Generic.IList<T>, System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyList<T> et System.Collections.Generic.IReadOnlyCollection<T>. Les implémentations sont fournies aux tableaux au moment de l’exécution et, par conséquent, les interfaces génériques n’apparaissent pas dans la syntaxe de déclaration de la classe Array. En outre, il n’existe aucune rubrique de référence pour les membres d’interface accessibles uniquement en cas de conversion d’un tableau vers le type d’interface générique (implémentations d’interface explicites). La chose clé à prendre en compte lorsque vous castez un tableau sur l’une de ces interfaces est que les membres qui ajoutent, insèrent ou suppriment des éléments lèvent NotSupportedException.

Type objets fournissent des informations sur les déclarations de type de tableau. Array objets avec le même type de tableau partagent le même objet Type.

Type.IsArray et Type.GetElementType risque de ne pas renvoyer les résultats attendus avec Array, car si un tableau est converti en type Array, le résultat est un objet, et non un tableau. Autrement dit, typeof(System.Array).IsArray retourne false, et typeof(System.Array).GetElementType retourne null.

La méthode Array.Copy copie des éléments non seulement entre les tableaux du même type, mais également entre les tableaux standard de différents types ; il gère automatiquement le cast de type.

Certaines méthodes, telles que CreateInstance, Copy, CopyTo, GetValueet SetValue, fournissent des surcharges qui acceptent des entiers 64 bits en tant que paramètres pour prendre en charge de grands tableaux de capacité. LongLength et GetLongLength retourner des entiers 64 bits indiquant la longueur du tableau.

La Array n’est pas garantie d’être triée. Vous devez trier les Array avant d’effectuer des opérations (telles que BinarySearch) qui nécessitent le tri des Array.

L’utilisation d’un objet Array de pointeurs dans le code natif n’est pas prise en charge et lève une NotSupportedException pour plusieurs méthodes.

Propriétés

IsFixedSize	Obtient une valeur indiquant si le Array a une taille fixe.
IsReadOnly	Obtient une valeur indiquant si le Array est en lecture seule.
IsSynchronized	Obtient une valeur indiquant si l’accès au Array est synchronisé (thread safe).
Length	Obtient le nombre total d’éléments dans toutes les dimensions de la Array.
LongLength	Obtient un entier 64 bits qui représente le nombre total d’éléments dans toutes les dimensions du Array.
MaxLength	Obtient le nombre maximal d’éléments qui peuvent être contenus dans un tableau.
Rank	Obtient le rang (nombre de dimensions) de la Array. Par exemple, un tableau unidimensionnel retourne 1, un tableau à deux dimensions retourne 2, et ainsi de suite.
SyncRoot	Obtient un objet qui peut être utilisé pour synchroniser l’accès au Array.

Méthodes

AsReadOnly<T>(T[])	Renvoie un wrapper en lecture seule pour le tableau spécifié.
BinarySearch(Array, Int32, Int32, Object)	Recherche une plage d’éléments dans un tableau trié unidimensionnel pour une valeur à l’aide de l’interface IComparable implémentée par chaque élément du tableau et par la valeur spécifiée.
BinarySearch(Array, Int32, Int32, Object, IComparer)	Recherche une plage d’éléments dans un tableau trié unidimensionnel pour une valeur à l’aide de l’interface de IComparer spécifiée.
BinarySearch(Array, Object)	Recherche un tableau trié unidimensionnel entier pour un élément spécifique, à l’aide de l’interface IComparable implémentée par chaque élément du tableau et par l’objet spécifié.
BinarySearch(Array, Object, IComparer)	Recherche dans un tableau trié unidimensionnel entier une valeur à l’aide de l’interface IComparer spécifiée.
BinarySearch<T>(T[], Int32, Int32, T)	Recherche une plage d’éléments dans un tableau trié unidimensionnel pour une valeur à l’aide de l’interface générique IComparable<T> implémentée par chaque élément de l'Array et par la valeur spécifiée.
BinarySearch<T>(T[], Int32, Int32, T, IComparer<T>)	Recherche une plage d’éléments dans un tableau trié unidimensionnel pour une valeur à l’aide de l’interface générique IComparer<T> spécifiée.
BinarySearch<T>(T[], T)	Recherche un tableau trié unidimensionnel entier pour un élément spécifique à l’aide de l’interface générique IComparable<T> implémentée par chaque élément de l'Array et par l’objet spécifié.
BinarySearch<T>(T[], T, IComparer<T>)	Recherche dans un tableau trié unidimensionnel entier une valeur à l’aide de l’interface générique spécifiée IComparer<T>.
Clear(Array)	Efface le contenu d’un tableau.
Clear(Array, Int32, Int32)	Définit une plage d’éléments dans un tableau sur la valeur par défaut de chaque type d’élément.
Clone()	Crée une copie superficielle du Array.
ConstrainedCopy(Array, Int32, Array, Int32, Int32)	Copie une plage d’éléments à partir d’un Array à partir de l’index source spécifié et les colle à une autre Array à partir de l’index de destination spécifié. Garantit que toutes les modifications sont annulées si la copie ne réussit pas complètement.
ConvertAll<TInput,TOutput>(TInput[], Converter<TInput,TOutput>)	Convertit un tableau d’un type en tableau d’un autre type.
Copy(Array, Array, Int32)	Copie une plage d’éléments d’une Array commençant au premier élément et les colle dans une autre Array en commençant au premier élément. La longueur est spécifiée sous la forme d’un entier 32 bits.
Copy(Array, Array, Int64)	Copie une plage d’éléments d’une Array commençant au premier élément et les colle dans une autre Array en commençant au premier élément. La longueur est spécifiée sous la forme d’un entier 64 bits.
Copy(Array, Int32, Array, Int32, Int32)	Copie une plage d’éléments à partir d’un Array à partir de l’index source spécifié et les colle à une autre Array à partir de l’index de destination spécifié. La longueur et les index sont spécifiés sous forme d’entiers 32 bits.
Copy(Array, Int64, Array, Int64, Int64)	Copie une plage d’éléments à partir d’un Array à partir de l’index source spécifié et les colle à une autre Array à partir de l’index de destination spécifié. La longueur et les index sont spécifiés sous forme d’entiers 64 bits.
CopyTo(Array, Int32)	Copie tous les éléments du tableau unidimensionnel actuel dans le tableau unidimensionnel spécifié à partir de l’index de tableau de destination spécifié. L’index est spécifié sous la forme d’un entier 32 bits.
CopyTo(Array, Int64)	Copie tous les éléments du tableau unidimensionnel actuel dans le tableau unidimensionnel spécifié à partir de l’index de tableau de destination spécifié. L’index est spécifié sous la forme d’un entier 64 bits.
CreateInstance(Type, Int32)	Crée un Array unidimensionnel de la Type et de la longueur spécifiées, avec indexation de base zéro.
CreateInstance(Type, Int32, Int32)	Crée un Array bidimensionnel de la Type et des longueurs de dimension spécifiées, avec indexation de base zéro.
CreateInstance(Type, Int32, Int32, Int32)	Crée un Array tridimensionnel de la Type et des longueurs de dimension spécifiées, avec indexation de base zéro.
CreateInstance(Type, Int32[])	Crée un Array multidimensionnel de la Type et des longueurs de dimension spécifiées, avec indexation de base zéro. Les longueurs de dimension sont spécifiées dans un tableau d’entiers 32 bits.
CreateInstance(Type, Int32[], Int32[])	Crée un Array multidimensionnel des longueurs de dimension et de Type spécifiées, avec les limites inférieures spécifiées.
CreateInstance(Type, Int64[])	Crée un Array multidimensionnel de la Type et des longueurs de dimension spécifiées, avec indexation de base zéro. Les longueurs de dimension sont spécifiées dans un tableau d’entiers 64 bits.
Empty<T>()	Retourne un tableau vide.
Equals(Object)	Détermine si l’objet spécifié est égal à l’objet actuel. (Hérité de Object)
Exists<T>(T[], Predicate<T>)	Détermine si le tableau spécifié contient des éléments qui correspondent aux conditions définies par le prédicat spécifié.
Fill<T>(T[], T)	Affecte le value donné de type T à chaque élément du arrayspécifié.
Fill<T>(T[], T, Int32, Int32)	Affecte le value de type donné T aux éléments de l'array spécifié qui se trouvent dans la plage de startIndex (inclusive) et le nombre d’indices de count suivant.
Find<T>(T[], Predicate<T>)	Recherche un élément qui correspond aux conditions définies par le prédicat spécifié et retourne la première occurrence dans l’ensemble du Array.
FindAll<T>(T[], Predicate<T>)	Récupère tous les éléments qui correspondent aux conditions définies par le prédicat spécifié.
FindIndex<T>(T[], Int32, Int32, Predicate<T>)	Recherche un élément qui correspond aux conditions définies par le prédicat spécifié et retourne l’index de base zéro de la première occurrence dans la plage d’éléments de l'Array qui commence à l’index spécifié et contient le nombre spécifié d’éléments.
FindIndex<T>(T[], Int32, Predicate<T>)	Recherche un élément qui correspond aux conditions définies par le prédicat spécifié et retourne l’index de base zéro de la première occurrence dans la plage d’éléments du Array qui s’étend de l’index spécifié au dernier élément.
FindIndex<T>(T[], Predicate<T>)	Recherche un élément qui correspond aux conditions définies par le prédicat spécifié et retourne l’index de base zéro de la première occurrence dans l’ensemble du Array.
FindLast<T>(T[], Predicate<T>)	Recherche un élément qui correspond aux conditions définies par le prédicat spécifié et retourne la dernière occurrence dans l’ensemble de la Array.
FindLastIndex<T>(T[], Int32, Int32, Predicate<T>)	Recherche un élément qui correspond aux conditions définies par le prédicat spécifié et retourne l’index de base zéro de la dernière occurrence dans la plage d’éléments du Array qui contient le nombre spécifié d’éléments et se termine à l’index spécifié.
FindLastIndex<T>(T[], Int32, Predicate<T>)	Recherche un élément qui correspond aux conditions définies par le prédicat spécifié et retourne l’index de base zéro de la dernière occurrence dans la plage d’éléments du Array qui s’étend du premier élément à l’index spécifié.
FindLastIndex<T>(T[], Predicate<T>)	Recherche un élément qui correspond aux conditions définies par le prédicat spécifié et retourne l’index de base zéro de la dernière occurrence dans l’ensemble de la Array.
ForEach<T>(T[], Action<T>)	Exécute l’action spécifiée sur chaque élément du tableau spécifié.
GetEnumerator()	Retourne un IEnumerator pour le Array.
GetHashCode()	Sert de fonction de hachage par défaut. (Hérité de Object)
GetLength(Int32)	Obtient un entier 32 bits qui représente le nombre d’éléments dans la dimension spécifiée du Array.
GetLongLength(Int32)	Obtient un entier 64 bits qui représente le nombre d’éléments dans la dimension spécifiée du Array.
GetLowerBound(Int32)	Obtient l’index du premier élément de la dimension spécifiée dans le tableau.
GetType()	Obtient la Type de l’instance actuelle. (Hérité de Object)
GetUpperBound(Int32)	Obtient l’index du dernier élément de la dimension spécifiée dans le tableau.
GetValue(Int32)	Obtient la valeur à la position spécifiée dans le Arrayunidimensionnel . L’index est spécifié sous la forme d’un entier 32 bits.
GetValue(Int32, Int32)	Obtient la valeur à la position spécifiée dans le Arraybidimensionnel . Les index sont spécifiés sous forme d’entiers 32 bits.
GetValue(Int32, Int32, Int32)	Obtient la valeur à la position spécifiée dans le Arraytridimensionnel . Les index sont spécifiés sous forme d’entiers 32 bits.
GetValue(Int32[])	Obtient la valeur à la position spécifiée dans le Arraymultidimensionnel . Les index sont spécifiés sous la forme d’un tableau d’entiers 32 bits.
GetValue(Int64)	Obtient la valeur à la position spécifiée dans le Arrayunidimensionnel . L’index est spécifié sous la forme d’un entier 64 bits.
GetValue(Int64, Int64)	Obtient la valeur à la position spécifiée dans le Arraybidimensionnel . Les index sont spécifiés sous forme d’entiers 64 bits.
GetValue(Int64, Int64, Int64)	Obtient la valeur à la position spécifiée dans le Arraytridimensionnel . Les index sont spécifiés sous forme d’entiers 64 bits.
GetValue(Int64[])	Obtient la valeur à la position spécifiée dans le Arraymultidimensionnel . Les index sont spécifiés sous la forme d’un tableau d’entiers 64 bits.
IndexOf(Array, Object)	Recherche l’objet spécifié et retourne l’index de sa première occurrence dans un tableau unidimensionnel.
IndexOf(Array, Object, Int32)	Recherche l’objet spécifié dans une plage d’éléments d’un tableau unidimensionnel et retourne l’index de sa première occurrence. La plage s’étend d’un index spécifié à la fin du tableau.
IndexOf(Array, Object, Int32, Int32)	Recherche l’objet spécifié dans une plage d’éléments d’un tableau unidimensionnel et retourne l’index de ifs first occurrence. La plage s’étend d’un index spécifié pour un nombre spécifié d’éléments.
IndexOf<T>(T[], T)	Recherche l’objet spécifié et retourne l’index de sa première occurrence dans un tableau unidimensionnel.
IndexOf<T>(T[], T, Int32)	Recherche l’objet spécifié dans une plage d’éléments d’un tableau unidimensionnel et retourne l’index de sa première occurrence. La plage s’étend d’un index spécifié à la fin du tableau.
IndexOf<T>(T[], T, Int32, Int32)	Recherche l’objet spécifié dans une plage d’éléments d’un tableau unidimensionnel et retourne l’index de sa première occurrence. La plage s’étend d’un index spécifié pour un nombre spécifié d’éléments.
Initialize()	Initialise chaque élément du type valeur Array en appelant le constructeur sans paramètre du type valeur.
LastIndexOf(Array, Object)	Recherche l’objet spécifié et retourne l’index de la dernière occurrence dans l’ensemble de l'Arrayunidimensionnel .
LastIndexOf(Array, Object, Int32)	Recherche l’objet spécifié et retourne l’index de la dernière occurrence dans la plage d’éléments de l'Array unidimensionnel qui s’étend du premier élément à l’index spécifié.
LastIndexOf(Array, Object, Int32, Int32)	Recherche l’objet spécifié et retourne l’index de la dernière occurrence dans la plage d’éléments de l'Array unidimensionnel qui contient le nombre spécifié d’éléments et se termine à l’index spécifié.
LastIndexOf<T>(T[], T)	Recherche l’objet spécifié et retourne l’index de la dernière occurrence dans l’ensemble de la Array.
LastIndexOf<T>(T[], T, Int32)	Recherche l’objet spécifié et retourne l’index de la dernière occurrence dans la plage d’éléments du Array qui s’étend du premier élément à l’index spécifié.
LastIndexOf<T>(T[], T, Int32, Int32)	Recherche l’objet spécifié et retourne l’index de la dernière occurrence dans la plage d’éléments du Array qui contient le nombre spécifié d’éléments et se termine à l’index spécifié.
MemberwiseClone()	Crée une copie superficielle du Objectactuel. (Hérité de Object)
Resize<T>(T[], Int32)	Modifie le nombre d’éléments d’un tableau unidimensionnel à la nouvelle taille spécifiée.
Reverse(Array)	Inverse la séquence des éléments dans l’ensemble de l'Arrayunidimensionnel .
Reverse(Array, Int32, Int32)	Inverse la séquence d’un sous-ensemble des éléments de l'Arrayunidimensionnel .
Reverse<T>(T[])	Inverse la séquence des éléments dans le tableau générique unidimensionnel.
Reverse<T>(T[], Int32, Int32)	Inverse la séquence d’un sous-ensemble des éléments dans le tableau générique unidimensionnel.
SetValue(Object, Int32)	Définit une valeur sur l’élément à la position spécifiée dans le Arrayunidimensionnel . L’index est spécifié sous la forme d’un entier 32 bits.
SetValue(Object, Int32, Int32)	Définit une valeur sur l’élément à la position spécifiée dans le Arraybidimensionnel . Les index sont spécifiés sous forme d’entiers 32 bits.
SetValue(Object, Int32, Int32, Int32)	Définit une valeur sur l’élément à la position spécifiée dans le Arraytridimensionnel . Les index sont spécifiés sous forme d’entiers 32 bits.
SetValue(Object, Int32[])	Définit une valeur sur l’élément à la position spécifiée dans le Arraymultidimensionnel . Les index sont spécifiés sous la forme d’un tableau d’entiers 32 bits.
SetValue(Object, Int64)	Définit une valeur sur l’élément à la position spécifiée dans le Arrayunidimensionnel . L’index est spécifié sous la forme d’un entier 64 bits.
SetValue(Object, Int64, Int64)	Définit une valeur sur l’élément à la position spécifiée dans le Arraybidimensionnel . Les index sont spécifiés sous forme d’entiers 64 bits.
SetValue(Object, Int64, Int64, Int64)	Définit une valeur sur l’élément à la position spécifiée dans le Arraytridimensionnel . Les index sont spécifiés sous forme d’entiers 64 bits.
SetValue(Object, Int64[])	Définit une valeur sur l’élément à la position spécifiée dans le Arraymultidimensionnel . Les index sont spécifiés sous la forme d’un tableau d’entiers 64 bits.
Sort(Array)	Trie les éléments dans une Array unidimensionnelle entière à l’aide de l’implémentation IComparable de chaque élément du Array.
Sort(Array, Array)	Trie une paire d’objets Array unidimensionnels (l’un contient les clés et l’autre contient les éléments correspondants) en fonction des clés du premier Array à l’aide de l’implémentation IComparable de chaque clé.
Sort(Array, Array, IComparer)	Trie une paire d’objets Array unidimensionnels (l’un contient les clés et l’autre contient les éléments correspondants) en fonction des clés du premier Array à l’aide du IComparerspécifié.
Sort(Array, Array, Int32, Int32)	Trie une plage d’éléments dans une paire d’objets Array unidimensionnels (l’un contient les clés et l’autre contient les éléments correspondants) en fonction des clés du premier Array à l’aide de l’implémentation IComparable de chaque clé.
Sort(Array, Array, Int32, Int32, IComparer)	Trie une plage d’éléments dans une paire d’objets Array unidimensionnels (l’un contient les clés et l’autre contient les éléments correspondants) en fonction des clés du premier Array à l’aide du IComparerspécifié.
Sort(Array, IComparer)	Trie les éléments dans un Array unidimensionnel à l’aide du IComparerspécifié.
Sort(Array, Int32, Int32)	Trie les éléments dans une plage d’éléments d’un Array unidimensionnel à l’aide de l’implémentation IComparable de chaque élément du Array.
Sort(Array, Int32, Int32, IComparer)	Trie les éléments d’une plage d’éléments dans une Array unidimensionnelle à l’aide du IComparerspécifié.
Sort<T>(T[])	Trie les éléments d’une Array entière à l’aide de l’implémentation d’interface générique IComparable<T> de chaque élément du Array.
Sort<T>(T[], Comparison<T>)	Trie les éléments d’un Array à l’aide du Comparison<T>spécifié.
Sort<T>(T[], IComparer<T>)	Trie les éléments d’un Array à l’aide de l’interface générique IComparer<T> spécifiée.
Sort<T>(T[], Int32, Int32)	Trie les éléments d’une plage d’éléments d’un Array à l’aide de l’implémentation d’interface générique IComparable<T> de chaque élément du Array.
Sort<T>(T[], Int32, Int32, IComparer<T>)	Trie les éléments dans une plage d’éléments d’un Array à l’aide de l’interface générique IComparer<T> spécifiée.
Sort<TKey,TValue>(TKey[], TValue[])	Trie une paire d’objets Array (l’un contient les clés et l’autre contient les éléments correspondants) en fonction des clés du premier Array à l’aide de l’implémentation d’interface générique IComparable<T> de chaque clé.
Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>)	Trie une paire d’objets Array (l’un contient les clés et l’autre contient les éléments correspondants) en fonction des clés du premier Array à l’aide de l’interface générique IComparer<T> spécifiée.
Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32)	Trie une plage d’éléments dans une paire d’objets Array (l’un contient les clés et l’autre contient les éléments correspondants) en fonction des clés du premier Array à l’aide de l’implémentation d’interface générique IComparable<T> de chaque clé.
Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>)	Trie une plage d’éléments dans une paire d’objets Array (l’une contient les clés et l’autre contient les éléments correspondants) en fonction des clés du premier Array à l’aide de l’interface générique IComparer<T> spécifiée.
ToString()	Retourne une chaîne qui représente l’objet actuel. (Hérité de Object)
TrueForAll<T>(T[], Predicate<T>)	Détermine si chaque élément du tableau correspond aux conditions définies par le prédicat spécifié.

Implémentations d’interfaces explicites

ICollection.Count	Obtient le nombre d’éléments contenus dans la Array.
IList.Add(Object)	L’appel de cette méthode lève toujours une exception NotSupportedException.
IList.Clear()	Supprime tous les éléments de la IList.
IList.Contains(Object)	Détermine si un élément se trouve dans le IList.
IList.IndexOf(Object)	Détermine l’index d’un élément spécifique dans le IList.
IList.Insert(Int32, Object)	Insère un élément dans le IList à l’index spécifié.
IList.Item[Int32]	Obtient ou définit l’élément à l’index spécifié.
IList.Remove(Object)	Supprime la première occurrence d’un objet spécifique de l'IList.
IList.RemoveAt(Int32)	Supprime l’élément IList à l’index spécifié.
IStructuralComparable.CompareTo(Object, IComparer)	Détermine si l’objet de collection actuel précède, se produit à la même position que ou suit un autre objet dans l’ordre de tri.
IStructuralEquatable.Equals(Object, IEqualityComparer)	Détermine si un objet est égal à l’instance actuelle.
IStructuralEquatable.GetHashCode(IEqualityComparer)	Retourne un code de hachage pour l’instance actuelle.

Méthodes d’extension

Cast<TResult>(IEnumerable)	Convertit les éléments d’un IEnumerable en type spécifié.
OfType<TResult>(IEnumerable)	Filtre les éléments d’une IEnumerable en fonction d’un type spécifié.
AsParallel(IEnumerable)	Active la parallélisation d’une requête.
AsQueryable(IEnumerable)	Convertit un IEnumerable en IQueryable.

Cohérence de thread

Les membres statiques publics (Shared en Visual Basic) de ce type sont thread safe. Tous les membres d’instance ne sont pas garantis pour être thread-safe.

Cette implémentation ne fournit pas de wrapper synchronisé (thread safe) pour un Array; Toutefois, les classes .NET basées sur Array fournissent leur propre version synchronisée de la collection à l’aide de la propriété SyncRoot.

L’énumération par le biais d’une collection n’est intrinsèquement pas une procédure thread-safe. Même lorsqu’une collection est synchronisée, d’autres threads peuvent toujours modifier la collection, ce qui provoque la levée d’une exception par l’énumérateur. Pour garantir la sécurité des threads pendant l’énumération, vous pouvez verrouiller la collection pendant toute l’énumération ou intercepter les exceptions résultant des modifications apportées par d’autres threads.

Voir aussi

• Object
• Type
• effectuer des opérations de chaîne Culture-Insensitive dans des tableaux
• tableaux (Guide de programmation C#)
• Tableaux en F#
• Tableaux dans Visual Basic