Array Array Array Array Class

Définition

Fournit des méthodes pour la création, la manipulation, la recherche ainsi que le tri des tableaux et sert de classe de base pour tous les tableaux du 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
Héritage
ArrayArrayArrayArray
Attributs
Implémente

Exemples

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

L’exemple de code suivant crée et initialise un Array et affiche ses propriétés et ses éléments.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
 */
using System;

public class SamplesArray2
{
    public static void Main()
    {
        // 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);
    }


    public static 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 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 Array classe ne fait pas partie System.Collections des espaces de noms.The Array class is not part of the System.Collections namespaces. Toutefois, il est toujours considéré comme une collection, car il est basé IList sur l’interface.However, it is still considered a collection because it is based on the IList interface.

La Array classe est la classe de base pour les implémentations de langage qui prennent en charge des tableaux.The Array class is the base class for language implementations that support arrays. Toutefois, seuls le système et les compilateurs peuvent dériver explicitement de Array la classe.However, only the system and compilers can derive explicitly from the Array class. Les utilisateurs doivent employer les constructions de tableau fournies par le langage.Users should employ the array constructs provided by the language.

Un élément est une valeur dans un Array.An element is a value in an Array. La longueur d’un Array est le nombre total d’éléments qu’il peut contenir.The length of an Array is the total number of elements it can contain. La limite inférieure d’un Array est l’index de son premier élément.The lower bound of an Array is the index of its first element. Un Array peut avoir n’importe quelle limite inférieure, mais il a une limite inférieure de zéro par défaut.An Array can have any lower bound, but it has a lower bound of zero by default. Une limite inférieure différente peut être définie lors de la création d’une Array instance de CreateInstancela classe à l’aide de. Un multidimensionnel Array peut avoir des limites différentes pour chaque dimension.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. Un tableau peut avoir un maximum de 32 dimensions.An array can have a maximum of 32 dimensions.

Contrairement aux classes dans les System.Collections espaces de noms Array , a une capacité fixe.Unlike the classes in the System.Collections namespaces, Array has a fixed capacity. Pour augmenter la capacité, vous devez créer un nouvel Array objet avec la capacité requise, copier les éléments de l’ancien Array objet vers le nouveau, puis supprimer l’ancien Array.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 taille du tableau est limitée à un total de 4 milliards éléments, et à un index maximal de 0X7FEFFFFF dans une dimension donnée (0X7FFFFFC7 pour les tableaux d’octets et les tableaux de structures sur un octet).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).

.NET Framework uniquement : Par défaut, la taille maximale d’un Array est de 2 gigaoctets (Go)..NET Framework only: By default, the maximum size of an Array is 2 gigabytes (GB). Dans un environnement 64 bits, vous pouvez éviter la restriction de taille en affectant enabled à true l’attribut de l’élément de configuration gcAllowVeryLargeObjects la valeur dans l’environnement d’exécution.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.

Les tableaux unidimensionnels implémentent System.Collections.Generic.IList<T>les System.Collections.Generic.ICollection<T> System.Collections.Generic.IEnumerable<T> System.Collections.Generic.IReadOnlyList<T> interfaces génériques, System.Collections.Generic.IReadOnlyCollection<T> , et.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. 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 pour Array la classe.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. En outre, il n’existe pas de rubriques de référence pour les membres d’interface accessibles uniquement en effectuant un cast d’un tableau vers le type d’interface générique (implémentations d’interface explicites).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). La principale chose à savoir quand vous effectuez un cast d’un tableau vers l’une de ces interfaces est que les membres qui ajoutent, insèrent NotSupportedExceptionou suppriment des éléments lèvent.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.

Typeles objets fournissent des informations sur les déclarations de type tableau.Type objects provide information about array type declarations. Arrayles objets avec le même type de tableau partagent Type le même objet.Array objects with the same array type share the same Type object.

Type.IsArrayet Type.GetElementType peuvent ne pas retourner les résultats attendus avec Array , car si un tableau est casté en type Array, le résultat est un objet, et non un tableau.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. Autrement dit, typeof(System.Array).IsArray retourne falseet typeof(System.Array).GetElementType retourne. nullThat is, typeof(System.Array).IsArray returns false, and typeof(System.Array).GetElementType returns null.

La Array.Copy méthode copie les éléments non seulement entre les tableaux du même type, mais également entre les tableaux standard de types différents ; elle gère automatiquement la conversion de type.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.

Certaines méthodes, telles que CreateInstance CopyTo, Copy GetValue,,, et SetValue, fournissent des surcharges qui acceptent des entiers 64 bits comme paramètres pour prendre en charge des tableaux de grande capacité.Some methods, such as CreateInstance, Copy, CopyTo, GetValue, and SetValue, provide overloads that accept 64-bit integers as parameters to accommodate large capacity arrays. LongLengthet GetLongLength retournent des entiers 64 bits indiquant la longueur du tableau.LongLength and GetLongLength return 64-bit integers indicating the length of the array.

Il Array n’est pas garanti que le tri soit effectué.The Array is not guaranteed to be sorted. Vous devez trier avant Array d’effectuer des opérations (telles que BinarySearch) qui nécessitent le Array tri de.You must sort the Array prior to performing operations (such as BinarySearch) that require the Array to be sorted.

L’utilisation Array d’un objet de pointeurs en code natif n’est pas prise en NotSupportedException charge et lèvera une pour plusieurs méthodes.Using an Array object of pointers in native code is not supported and will throw a NotSupportedException for several methods.

Propriétés

IsFixedSize IsFixedSize IsFixedSize IsFixedSize

Obtient une valeur indiquant si Array est de taille fixe.Gets a value indicating whether the Array has a fixed size.

IsReadOnly IsReadOnly IsReadOnly IsReadOnly

Obtient une valeur indiquant si Array est en lecture seule.Gets a value indicating whether the Array is read-only.

IsSynchronized IsSynchronized IsSynchronized IsSynchronized

Obtient une valeur indiquant si l'accès à Array est synchronisé (thread-safe).Gets a value indicating whether access to the Array is synchronized (thread safe).

Length Length Length Length

Obtient le nombre total d’éléments dans toutes les dimensions du Array.Gets the total number of elements in all the dimensions of the Array.

LongLength LongLength LongLength LongLength

Obtient un entier 64 bits qui représente le nombre total d’éléments dans toutes les dimensions du Array.Gets a 64-bit integer that represents the total number of elements in all the dimensions of the Array.

Rank Rank Rank Rank

Obtient le rang (nombre de dimensions) de Array.Gets the rank (number of dimensions) of the Array. Par exemple, un tableau unidimensionnel retourne 1, un tableau bidimensionnel retourne 2, etc.For example, a one-dimensional array returns 1, a two-dimensional array returns 2, and so on.

SyncRoot SyncRoot SyncRoot SyncRoot

Obtient un objet qui peut être utilisé pour synchroniser l'accès à Array.Gets an object that can be used to synchronize access to the Array.

Méthodes

AsReadOnly<T>(T[]) AsReadOnly<T>(T[]) AsReadOnly<T>(T[]) AsReadOnly<T>(T[])

Retourne un wrapper en lecture seule pour le tableau spécifié.Returns a read-only wrapper for the specified array.

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

Recherche une valeur dans une plage d’éléments d’un tableau trié unidimensionnel, à l’aide de l’interface IComparable implémentée par chaque élément du tableau et par la valeur spécifiée.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) BinarySearch(Array, Int32, Int32, Object, IComparer) BinarySearch(Array, Int32, Int32, Object, IComparer) BinarySearch(Array, Int32, Int32, Object, IComparer)

Recherche une valeur dans une plage d’éléments d’un tableau trié unidimensionnel à l’aide de l’interface IComparer spécifiée.Searches a range of elements in a one-dimensional sorted array for a value, using the specified IComparer interface.

BinarySearch(Array, Object) BinarySearch(Array, Object) BinarySearch(Array, Object) BinarySearch(Array, Object)

Recherche un élément spécifique dans tout un tableau trié unidimensionnel, à l’aide de l’interface IComparable implémentée par chaque élément du tableau et par l’objet spécifié.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) BinarySearch(Array, Object, IComparer) BinarySearch(Array, Object, IComparer) BinarySearch(Array, Object, IComparer)

Recherche une valeur dans l’intégralité d’un tableau trié unidimensionnel, à l’aide de l’interface IComparer spécifiée.Searches an entire one-dimensional sorted array for a value using the specified IComparer interface.

BinarySearch<T>(T[], Int32, Int32, T) BinarySearch<T>(T[], Int32, Int32, T) BinarySearch<T>(T[], Int32, Int32, T) BinarySearch<T>(T[], Int32, Int32, T)

Recherche une valeur dans une plage d’éléments d’un tableau trié unidimensionnel, à l’aide de l’interface générique IComparable<T> implémentée par chaque élément de Array et par la valeur spécifiée.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>) BinarySearch<T>(T[], Int32, Int32, T, IComparer<T>) BinarySearch<T>(T[], Int32, Int32, T, IComparer<T>) BinarySearch<T>(T[], Int32, Int32, T, IComparer<T>)

Recherche une valeur dans une plage d’éléments d’un tableau trié unidimensionnel, à l’aide de l’interface générique IComparer<T> spécifiée.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) BinarySearch<T>(T[], T) BinarySearch<T>(T[], T) BinarySearch<T>(T[], T)

Recherche un élément spécifique dans un tableau entier trié unidimensionnel, à l’aide de l’interface générique IComparable<T> implémentée par chaque élément de Array et par l’objet spécifié.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>) BinarySearch<T>(T[], T, IComparer<T>) BinarySearch<T>(T[], T, IComparer<T>) BinarySearch<T>(T[], T, IComparer<T>)

Recherche une valeur dans l’intégralité d’un tableau trié unidimensionnel, à l’aide de l’interface générique IComparer<T> spécifiée.Searches an entire one-dimensional sorted array for a value using the specified IComparer<T> generic interface.

Clear(Array, Int32, Int32) Clear(Array, Int32, Int32) Clear(Array, Int32, Int32) Clear(Array, Int32, Int32)

Définit une plage d'éléments dans un tableau à la valeur par défaut de chaque type d'élément.Sets a range of elements in an array to the default value of each element type.

Clone() Clone() Clone() Clone()

Crée une copie superficielle de Array.Creates a shallow copy of the Array.

ConstrainedCopy(Array, Int32, Array, Int32, Int32) ConstrainedCopy(Array, Int32, Array, Int32, Int32) ConstrainedCopy(Array, Int32, Array, Int32, Int32) ConstrainedCopy(Array, Int32, Array, Int32, Int32)

Copie une plage d’éléments à partir d’un Array commençant à l’index source spécifié, puis les colle dans un autre Array commençant à l’index de destination spécifié.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. Garantit que toutes les modifications sont annulées si la copie ne se déroule pas intégralement avec succès.Guarantees that all changes are undone if the copy does not succeed completely.

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

Convertit un tableau d'un type en un tableau d'un autre type.Converts an array of one type to an array of another type.

Copy(Array, Array, Int32) Copy(Array, Array, Int32) Copy(Array, Array, Int32) Copy(Array, Array, Int32)

Copie une série d’éléments de Array en commençant au premier élément, et les colle dans un autre Array en commençant au premier élément.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 longueur est spécifiée sous forme d'un entier 32 bits.The length is specified as a 32-bit integer.

Copy(Array, Array, Int64) Copy(Array, Array, Int64) Copy(Array, Array, Int64) Copy(Array, Array, Int64)

Copie une série d’éléments de Array en commençant au premier élément, et les colle dans un autre Array en commençant au premier élément.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 longueur est spécifiée sous forme d'un entier 64 bits.The length is specified as a 64-bit integer.

Copy(Array, Int32, Array, Int32, Int32) Copy(Array, Int32, Array, Int32, Int32) Copy(Array, Int32, Array, Int32, Int32) Copy(Array, Int32, Array, Int32, Int32)

Copie une plage d’éléments à partir d’un Array commençant à l’index source spécifié, puis les colle dans un autre Array commençant à l’index de destination spécifié.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 longueur et les index sont spécifiés en tant qu'entiers 32 bits.The length and the indexes are specified as 32-bit integers.

Copy(Array, Int64, Array, Int64, Int64) Copy(Array, Int64, Array, Int64, Int64) Copy(Array, Int64, Array, Int64, Int64) Copy(Array, Int64, Array, Int64, Int64)

Copie une plage d’éléments à partir d’un Array commençant à l’index source spécifié, puis les colle dans un autre Array commençant à l’index de destination spécifié.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 longueur et les index sont spécifiés en tant qu'entiers 64 bits.The length and the indexes are specified as 64-bit integers.

CopyTo(Array, Int32) CopyTo(Array, Int32) CopyTo(Array, Int32) CopyTo(Array, Int32)

Copie tous les éléments du tableau unidimensionnel actuel dans le tableau unidimensionnel spécifié en commençant à l'index du tableau de destination spécifié.Copies all the elements of the current one-dimensional array to the specified one-dimensional array starting at the specified destination array index. L'index est spécifié en tant qu'entier 32 bits.The index is specified as a 32-bit integer.

CopyTo(Array, Int64) CopyTo(Array, Int64) CopyTo(Array, Int64) CopyTo(Array, Int64)

Copie tous les éléments du tableau unidimensionnel actuel dans le tableau unidimensionnel spécifié en commençant à l'index du tableau de destination spécifié.Copies all the elements of the current one-dimensional array to the specified one-dimensional array starting at the specified destination array index. L'index est spécifié en tant qu'entier 64 bits.The index is specified as a 64-bit integer.

CreateInstance(Type, Int32) CreateInstance(Type, Int32) CreateInstance(Type, Int32) CreateInstance(Type, Int32)

Crée un Array unidimensionnel du Type et de la longueur spécifiés, à l’aide d’un index de base zéro.Creates a one-dimensional Array of the specified Type and length, with zero-based indexing.

CreateInstance(Type, Int32, Int32) CreateInstance(Type, Int32, Int32) CreateInstance(Type, Int32, Int32) CreateInstance(Type, Int32, Int32)

Crée un Array à deux dimensions du Type et des longueurs de dimensions spécifiés, à l’aide d’un index de base zéro.Creates a two-dimensional Array of the specified Type and dimension lengths, with zero-based indexing.

CreateInstance(Type, Int32, Int32, Int32) CreateInstance(Type, Int32, Int32, Int32) CreateInstance(Type, Int32, Int32, Int32) CreateInstance(Type, Int32, Int32, Int32)

Crée un Array à trois dimensions du Type et des longueurs de dimensions spécifiés, à l’aide d’un index de base zéro.Creates a three-dimensional Array of the specified Type and dimension lengths, with zero-based indexing.

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

Crée un Array multidimensionnel du Type et des longueurs de dimensions spécifiés, à l’aide d’un index de base zéro.Creates a multidimensional Array of the specified Type and dimension lengths, with zero-based indexing. Les longueurs de dimensions sont spécifiées en tant qu'entiers 32 bits.The dimension lengths are specified in an array of 32-bit integers.

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

Crée un Array multidimensionnel du Type et des longueurs de dimensions spécifiés, avec les limites inférieures déterminées.Creates a multidimensional Array of the specified Type and dimension lengths, with the specified lower bounds.

CreateInstance(Type, Int64[]) CreateInstance(Type, Int64[]) CreateInstance(Type, Int64[]) CreateInstance(Type, Int64[])

Crée un Array multidimensionnel du Type et des longueurs de dimensions spécifiés, à l’aide d’un index de base zéro.Creates a multidimensional Array of the specified Type and dimension lengths, with zero-based indexing. Les longueurs de dimensions sont spécifiées en tant qu'entiers 64 bits.The dimension lengths are specified in an array of 64-bit integers.

Empty<T>() Empty<T>() Empty<T>() Empty<T>()

Retourne un tableau vide.Returns an empty array.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

(Inherited from Object)
Exists<T>(T[], Predicate<T>) Exists<T>(T[], Predicate<T>) Exists<T>(T[], Predicate<T>) 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é.Determines whether the specified array contains elements that match the conditions defined by the specified predicate.

Fill<T>(T[], T) Fill<T>(T[], T) Fill<T>(T[], T) Fill<T>(T[], T)
Fill<T>(T[], T, Int32, Int32) Fill<T>(T[], T, Int32, Int32) Fill<T>(T[], T, Int32, Int32) Fill<T>(T[], T, Int32, Int32)
Find<T>(T[], Predicate<T>) Find<T>(T[], Predicate<T>) Find<T>(T[], Predicate<T>) 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 le Array entier.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>) FindAll<T>(T[], Predicate<T>) FindAll<T>(T[], Predicate<T>) FindAll<T>(T[], Predicate<T>)

Récupère tous les éléments qui correspondent aux conditions définies par le prédicat spécifié.Retrieves all the elements that match the conditions defined by the specified predicate.

FindIndex<T>(T[], Int32, Int32, Predicate<T>) FindIndex<T>(T[], Int32, Int32, Predicate<T>) FindIndex<T>(T[], Int32, Int32, Predicate<T>) 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 trouvée dans la plage d'éléments de Array qui commence à l'index spécifié et contient le nombre d'éléments spécifié.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>) FindIndex<T>(T[], Int32, Predicate<T>) FindIndex<T>(T[], Int32, Predicate<T>) 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 trouvée dans la plage d'éléments de Array qui s'étend de l'index spécifié au dernier élément.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>) FindIndex<T>(T[], Predicate<T>) FindIndex<T>(T[], Predicate<T>) 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 trouvée dans le Array entier.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>) FindLast<T>(T[], Predicate<T>) FindLast<T>(T[], Predicate<T>) 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 le Array entier.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>) FindLastIndex<T>(T[], Int32, Int32, Predicate<T>) FindLastIndex<T>(T[], Int32, Int32, Predicate<T>) 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 d'éléments spécifié et se termine à l'index spécifié.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>) FindLastIndex<T>(T[], Int32, Predicate<T>) FindLastIndex<T>(T[], Int32, Predicate<T>) 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 trouvée dans la plage d'éléments du Array qui s'étend du premier élément à l'index spécifié.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>) FindLastIndex<T>(T[], Predicate<T>) FindLastIndex<T>(T[], Predicate<T>) 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 le Array entier.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>) ForEach<T>(T[], Action<T>) ForEach<T>(T[], Action<T>) ForEach<T>(T[], Action<T>)

Exécute l'action spécifiée sur chaque élément du tableau spécifié.Performs the specified action on each element of the specified array.

GetEnumerator() GetEnumerator() GetEnumerator() GetEnumerator()

Retourne IEnumerator pour l'objet Array.Returns an IEnumerator for the Array.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fait office de fonction de hachage par défaut.Serves as the default hash function.

(Inherited from Object)
GetLength(Int32) GetLength(Int32) GetLength(Int32) GetLength(Int32)

Obtient un entier 32 bits qui représente le nombre d'éléments dans la dimension spécifiée de Array.Gets a 32-bit integer that represents the number of elements in the specified dimension of the Array.

GetLongLength(Int32) GetLongLength(Int32) GetLongLength(Int32) GetLongLength(Int32)

Obtient un entier 64 bits qui représente le nombre d’éléments dans la dimension spécifiée de Array.Gets a 64-bit integer that represents the number of elements in the specified dimension of the Array.

GetLowerBound(Int32) GetLowerBound(Int32) GetLowerBound(Int32) GetLowerBound(Int32)

Obtient l'index du premier élément de la dimension spécifiée dans le tableau.Gets the index of the first element of the specified dimension in the array.

GetType() GetType() GetType() GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Inherited from Object)
GetUpperBound(Int32) GetUpperBound(Int32) GetUpperBound(Int32) GetUpperBound(Int32)

Obtient l'index du dernier élément de la dimension spécifiée dans le tableau.Gets the index of the last element of the specified dimension in the array.

GetValue(Int32) GetValue(Int32) GetValue(Int32) GetValue(Int32)

Obtient la valeur à la position spécifiée du Array unidimensionnel.Gets the value at the specified position in the one-dimensional Array. L'index est spécifié en tant qu'entier 32 bits.The index is specified as a 32-bit integer.

GetValue(Int32, Int32) GetValue(Int32, Int32) GetValue(Int32, Int32) GetValue(Int32, Int32)

Obtient la valeur à la position spécifiée du Array à deux dimensions.Gets the value at the specified position in the two-dimensional Array. Les index sont spécifiés en tant qu'entiers 32 bits.The indexes are specified as 32-bit integers.

GetValue(Int32, Int32, Int32) GetValue(Int32, Int32, Int32) GetValue(Int32, Int32, Int32) GetValue(Int32, Int32, Int32)

Obtient la valeur à la position spécifiée du Array à trois dimensions.Gets the value at the specified position in the three-dimensional Array. Les index sont spécifiés en tant qu'entiers 32 bits.The indexes are specified as 32-bit integers.

GetValue(Int32[]) GetValue(Int32[]) GetValue(Int32[]) GetValue(Int32[])

Obtient la valeur à la position spécifiée du Array multidimensionnel.Gets the value at the specified position in the multidimensional Array. Les index sont spécifiés sous la forme d'un tableau d'entiers 32 bits.The indexes are specified as an array of 32-bit integers.

GetValue(Int64) GetValue(Int64) GetValue(Int64) GetValue(Int64)

Obtient la valeur à la position spécifiée du Array unidimensionnel.Gets the value at the specified position in the one-dimensional Array. L'index est spécifié en tant qu'entier 64 bits.The index is specified as a 64-bit integer.

GetValue(Int64, Int64) GetValue(Int64, Int64) GetValue(Int64, Int64) GetValue(Int64, Int64)

Obtient la valeur à la position spécifiée du Array à deux dimensions.Gets the value at the specified position in the two-dimensional Array. Les index sont spécifiés en tant qu’entiers 64 bits.The indexes are specified as 64-bit integers.

GetValue(Int64, Int64, Int64) GetValue(Int64, Int64, Int64) GetValue(Int64, Int64, Int64) GetValue(Int64, Int64, Int64)

Obtient la valeur à la position spécifiée du Array à trois dimensions.Gets the value at the specified position in the three-dimensional Array. Les index sont spécifiés en tant qu’entiers 64 bits.The indexes are specified as 64-bit integers.

GetValue(Int64[]) GetValue(Int64[]) GetValue(Int64[]) GetValue(Int64[])

Obtient la valeur à la position spécifiée du Array multidimensionnel.Gets the value at the specified position in the multidimensional Array. Les index sont spécifiés sous la forme d’un tableau d’entiers 64 bits.The indexes are specified as an array of 64-bit integers.

IndexOf(Array, Object) IndexOf(Array, Object) IndexOf(Array, Object) IndexOf(Array, Object)

Recherche l'objet spécifié et retourne l'index de sa première occurrence dans un tableau unidimensionnel.Searches for the specified object and returns the index of its first occurrence in a one-dimensional array.

IndexOf(Array, Object, Int32) IndexOf(Array, Object, Int32) IndexOf(Array, Object, Int32) 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.Searches for the specified object in a range of elements of a one-dimensional array, and returns the index of its first occurrence. La plage s’étend d’un index spécifié à la fin du tableau.The range extends from a specified index to the end of the array.

IndexOf(Array, Object, Int32, Int32) IndexOf(Array, Object, Int32, Int32) IndexOf(Array, Object, Int32, Int32) 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 sa première occurrence.Searches for the specified object in a range of elements of a one-dimensional array, and returns the index of ifs first occurrence. La plage commence à un index spécifié pour un nombre d'éléments spécifié.The range extends from a specified index for a specified number of elements.

IndexOf<T>(T[], T) IndexOf<T>(T[], T) IndexOf<T>(T[], T) IndexOf<T>(T[], T)

Recherche l'objet spécifié et retourne l'index de sa première occurrence dans un tableau unidimensionnel.Searches for the specified object and returns the index of its first occurrence in a one-dimensional array.

IndexOf<T>(T[], T, Int32) IndexOf<T>(T[], T, Int32) IndexOf<T>(T[], T, Int32) 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.Searches for the specified object in a range of elements of a one dimensional array, and returns the index of its first occurrence. La plage s’étend d’un index spécifié à la fin du tableau.The range extends from a specified index to the end of the array.

IndexOf<T>(T[], T, Int32, Int32) IndexOf<T>(T[], T, Int32, Int32) IndexOf<T>(T[], T, Int32, Int32) 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.Searches for the specified object in a range of elements of a one-dimensional array, and returns the index of its first occurrence. La plage commence à un index spécifié pour un nombre d'éléments spécifié.The range extends from a specified index for a specified number of elements.

Initialize() Initialize() Initialize() Initialize()

Initialise tous les éléments du type valeur Array en appelant le constructeur sans paramètre du type valeur.Initializes every element of the value-type Array by calling the parameterless constructor of the value type.

LastIndexOf(Array, Object) LastIndexOf(Array, Object) LastIndexOf(Array, Object) LastIndexOf(Array, Object)

Recherche l'objet spécifié et retourne l'index de la dernière occurrence dans l'ensemble du Array unidimensionnel.Searches for the specified object and returns the index of the last occurrence within the entire one-dimensional Array.

LastIndexOf(Array, Object, Int32) LastIndexOf(Array, Object, Int32) LastIndexOf(Array, Object, Int32) LastIndexOf(Array, Object, Int32)

Recherche l'objet spécifié et retourne l'index de la dernière occurrence dans la plage d'éléments du Array unidimensionnel qui s'étend du premier élément jusqu'à l'index spécifié.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) LastIndexOf(Array, Object, Int32, Int32) LastIndexOf(Array, Object, Int32, Int32) 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 du Array unidimensionnel qui contient le nombre d'éléments spécifié et se termine à l'index spécifié.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) LastIndexOf<T>(T[], T) LastIndexOf<T>(T[], T) LastIndexOf<T>(T[], T)

Recherche l'objet spécifié et retourne l'index de la dernière occurrence dans le Array entier.Searches for the specified object and returns the index of the last occurrence within the entire Array.

LastIndexOf<T>(T[], T, Int32) LastIndexOf<T>(T[], T, Int32) LastIndexOf<T>(T[], T, Int32) 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 jusqu'à l'index spécifié.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) LastIndexOf<T>(T[], T, Int32, Int32) LastIndexOf<T>(T[], T, Int32, Int32) 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 d'éléments spécifié et se termine à l'index spécifié.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() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

(Inherited from Object)
Resize<T>(T[], Int32) Resize<T>(T[], Int32) Resize<T>(T[], Int32) Resize<T>(T[], Int32)

Modifie le nombre d'éléments d'un tableau unidimensionnel avec la nouvelle taille spécifiée.Changes the number of elements of a one-dimensional array to the specified new size.

Reverse(Array) Reverse(Array) Reverse(Array) Reverse(Array)

Inverse l'ordre des éléments dans l'intégralité du Array unidimensionnel.Reverses the sequence of the elements in the entire one-dimensional Array.

Reverse(Array, Int32, Int32) Reverse(Array, Int32, Int32) Reverse(Array, Int32, Int32) Reverse(Array, Int32, Int32)

Inverse l'ordre des éléments dans la plage d'éléments d'un Array unidimensionnel.Reverses the sequence of the elements in a range of elements in the one-dimensional Array.

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

Affecte une valeur à l'élément à la position spécifiée du Array unidimensionnel.Sets a value to the element at the specified position in the one-dimensional Array. L'index est spécifié en tant qu'entier 32 bits.The index is specified as a 32-bit integer.

SetValue(Object, Int32, Int32) SetValue(Object, Int32, Int32) SetValue(Object, Int32, Int32) SetValue(Object, Int32, Int32)

Affecte une valeur à l'élément à la position spécifiée du Array à deux dimensions.Sets a value to the element at the specified position in the two-dimensional Array. Les index sont spécifiés en tant qu'entiers 32 bits.The indexes are specified as 32-bit integers.

SetValue(Object, Int32, Int32, Int32) SetValue(Object, Int32, Int32, Int32) SetValue(Object, Int32, Int32, Int32) SetValue(Object, Int32, Int32, Int32)

Affecte une valeur à l'élément à la position spécifiée du Array à trois dimensions.Sets a value to the element at the specified position in the three-dimensional Array. Les index sont spécifiés en tant qu'entiers 32 bits.The indexes are specified as 32-bit integers.

SetValue(Object, Int32[]) SetValue(Object, Int32[]) SetValue(Object, Int32[]) SetValue(Object, Int32[])

Affecte une valeur à l'élément à la position spécifiée du Array multidimensionnel.Sets a value to the element at the specified position in the multidimensional Array. Les index sont spécifiés sous la forme d'un tableau d'entiers 32 bits.The indexes are specified as an array of 32-bit integers.

SetValue(Object, Int64) SetValue(Object, Int64) SetValue(Object, Int64) SetValue(Object, Int64)

Affecte une valeur à l'élément à la position spécifiée du Array unidimensionnel.Sets a value to the element at the specified position in the one-dimensional Array. L'index est spécifié en tant qu'entier 64 bits.The index is specified as a 64-bit integer.

SetValue(Object, Int64, Int64) SetValue(Object, Int64, Int64) SetValue(Object, Int64, Int64) SetValue(Object, Int64, Int64)

Affecte une valeur à l'élément à la position spécifiée du Array à deux dimensions.Sets a value to the element at the specified position in the two-dimensional Array. Les index sont spécifiés en tant qu’entiers 64 bits.The indexes are specified as 64-bit integers.

SetValue(Object, Int64, Int64, Int64) SetValue(Object, Int64, Int64, Int64) SetValue(Object, Int64, Int64, Int64) SetValue(Object, Int64, Int64, Int64)

Affecte une valeur à l'élément à la position spécifiée du Array à trois dimensions.Sets a value to the element at the specified position in the three-dimensional Array. Les index sont spécifiés en tant qu’entiers 64 bits.The indexes are specified as 64-bit integers.

SetValue(Object, Int64[]) SetValue(Object, Int64[]) SetValue(Object, Int64[]) SetValue(Object, Int64[])

Affecte une valeur à l'élément à la position spécifiée du Array multidimensionnel.Sets a value to the element at the specified position in the multidimensional Array. Les index sont spécifiés sous la forme d’un tableau d’entiers 64 bits.The indexes are specified as an array of 64-bit integers.

Sort(Array) Sort(Array) Sort(Array) Sort(Array)

Trie les éléments dans l'intégralité d'un Array unidimensionnel à l'aide de l'implémentation de IComparable de chaque élément de Array.Sorts the elements in an entire one-dimensional Array using the IComparable implementation of each element of the Array.

Sort(Array, Array) Sort(Array, Array) Sort(Array, Array) Sort(Array, Array)

Trie une paire d'objets Array unidimensionnels (l'un contient les clés et l'autre, les éléments correspondants) en fonction des clés du premier Array à l'aide de l'implémentation de IComparable de chaque clé.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) Sort(Array, Array, IComparer) Sort(Array, Array, IComparer) Sort(Array, Array, IComparer)

Trie une paire d'objets Array unidimensionnels (l'un contient les clés et l'autre, les éléments correspondants) en fonction des clés du premier Array à l'aide de l'objet IComparer spécifié.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) Sort(Array, Array, Int32, Int32) Sort(Array, Array, Int32, Int32) 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, les éléments correspondants) en fonction des clés du premier Array à l'aide de l'implémentation de IComparable de chaque clé.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) Sort(Array, Array, Int32, Int32, IComparer) Sort(Array, Array, Int32, Int32, IComparer) 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, les éléments correspondants) en fonction des clés du premier Array à l'aide de l'objet IComparer spécifié.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) Sort(Array, IComparer) Sort(Array, IComparer) Sort(Array, IComparer)

Trie les éléments d'un Array unidimensionnel à l'aide de l'objet IComparer spécifié.Sorts the elements in a one-dimensional Array using the specified IComparer.

Sort(Array, Int32, Int32) Sort(Array, Int32, Int32) Sort(Array, Int32, Int32) Sort(Array, Int32, Int32)

Trie les éléments d'une plage d'éléments d'un Array unidimensionnel à l'aide de l'implémentation de IComparable de chaque élément de 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) Sort(Array, Int32, Int32, IComparer) Sort(Array, Int32, Int32, IComparer) Sort(Array, Int32, Int32, IComparer)

Trie les éléments d'une plage d'éléments d'un Array unidimensionnel à l'aide de l'objet IComparer spécifié.Sorts the elements in a range of elements in a one-dimensional Array using the specified IComparer.

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

Trie les éléments dans l'intégralité d'un Array à l'aide de l'implémentation de l'interface générique IComparable<T> de chaque élément de 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>) Sort<T>(T[], Comparison<T>) Sort<T>(T[], Comparison<T>) Sort<T>(T[], Comparison<T>)

Trie les éléments dans un Array à l'aide de l'objet Comparison<T> spécifié.Sorts the elements in an Array using the specified Comparison<T>.

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

Trie les éléments dans un Array unidimensionnel à l'aide de l'interface générique IComparer<T> spécifiée.Sorts the elements in an Array using the specified IComparer<T> generic interface.

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

Trie les éléments d'une plage d'éléments d'un Array à l'aide de l'implémentation de l'interface générique IComparable<T> de chaque élément de 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>) Sort<T>(T[], Int32, Int32, IComparer<T>) Sort<T>(T[], Int32, Int32, IComparer<T>) 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.Sorts the elements in a range of elements in an Array using the specified IComparer<T> generic interface.

Sort<TKey,TValue>(TKey[], TValue[]) Sort<TKey,TValue>(TKey[], TValue[]) Sort<TKey,TValue>(TKey[], TValue[]) Sort<TKey,TValue>(TKey[], TValue[])

Trie une paire d'objets Array (l'un contient les clés et l'autre, les éléments correspondants) en fonction des clés du premier Array à l'aide de l'implémentation de l'interface générique IComparable<T> de chaque clé.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>) Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>)

Trie une paire d'objets Array (l'un contient les clés et l'autre, 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.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) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32)

Trie une plage d'éléments dans une paire d'objets Array unidimensionnels (l'un contient les clés et l'autre, 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é.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>) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>)

Trie une plage d'éléments dans une paire d'objets Array unidimensionnels (l'un contient les clés et l'autre, 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.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() ToString() ToString() ToString()

Retourne une chaîne qui représente l'objet actuel.Returns a string that represents the current object.

(Inherited from Object)
TrueForAll<T>(T[], Predicate<T>) TrueForAll<T>(T[], Predicate<T>) TrueForAll<T>(T[], Predicate<T>) TrueForAll<T>(T[], Predicate<T>)

Détermine si chaque élément dans le tableau correspond aux conditions définies par le prédicat spécifié.Determines whether every element in the array matches the conditions defined by the specified predicate.

Implémentations d’interfaces explicites

ICollection.Count ICollection.Count ICollection.Count ICollection.Count

Obtient le nombre d'éléments contenus dans le Array.Gets the number of elements contained in the Array.

ICollection.IsSynchronized ICollection.IsSynchronized ICollection.IsSynchronized ICollection.IsSynchronized

Obtient une valeur qui indique si l'accès à Array est synchronisé (thread safe).Gets a value that indicates whether access to the Array is synchronized (thread safe).

ICollection.SyncRoot ICollection.SyncRoot ICollection.SyncRoot ICollection.SyncRoot

Obtient un objet qui peut être utilisé pour synchroniser l'accès à Array.Gets an object that can be used to synchronize access to the Array.

IList.Add(Object) IList.Add(Object) IList.Add(Object) IList.Add(Object)

L’appel de cette méthode lève toujours une exception NotSupportedException.Calling this method always throws a NotSupportedException exception.

IList.Clear() IList.Clear() IList.Clear() IList.Clear()

Supprime tous les éléments de IList.Removes all items from the IList.

IList.Contains(Object) IList.Contains(Object) IList.Contains(Object) IList.Contains(Object)

Détermine si le IList contient un élément.Determines whether an element is in the IList.

IList.IndexOf(Object) IList.IndexOf(Object) IList.IndexOf(Object) IList.IndexOf(Object)

Détermine l'index d'un élément spécifique d'IList.Determines the index of a specific item in the IList.

IList.Insert(Int32, Object) IList.Insert(Int32, Object) IList.Insert(Int32, Object) IList.Insert(Int32, Object)

Insère un élément dans IList à l'index spécifié.Inserts an item to the IList at the specified index.

IList.IsFixedSize IList.IsFixedSize IList.IsFixedSize IList.IsFixedSize

Obtient une valeur qui indique si Array est de taille fixe.Gets a value that indicates whether the Array has a fixed size.

IList.IsReadOnly IList.IsReadOnly IList.IsReadOnly IList.IsReadOnly

Obtient une valeur qui indique si l'objet Array est en lecture seule.Gets a value that indicates whether the Array is read-only.

IList.Item[Int32] IList.Item[Int32] IList.Item[Int32] IList.Item[Int32]

Obtient ou définit l'élément au niveau de l'index spécifié.Gets or sets the element at the specified index.

IList.Remove(Object) IList.Remove(Object) IList.Remove(Object) IList.Remove(Object)

Supprime la première occurrence d'un objet spécifique de IList.Removes the first occurrence of a specific object from the IList.

IList.RemoveAt(Int32) IList.RemoveAt(Int32) IList.RemoveAt(Int32) IList.RemoveAt(Int32)

Supprime l'élément IList au niveau de l'index spécifié.Removes the IList item at the specified index.

IStructuralComparable.CompareTo(Object, IComparer) IStructuralComparable.CompareTo(Object, IComparer) IStructuralComparable.CompareTo(Object, IComparer) IStructuralComparable.CompareTo(Object, IComparer)

Détermine si l'objet collection actuel précède, se situe à la même position que, ou suit un autre objet dans l'ordre de tri.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) IStructuralEquatable.Equals(Object, IEqualityComparer) IStructuralEquatable.Equals(Object, IEqualityComparer) IStructuralEquatable.Equals(Object, IEqualityComparer)

Détermine si un objet est identique à l'instance actuelle.Determines whether an object is equal to the current instance.

IStructuralEquatable.GetHashCode(IEqualityComparer) IStructuralEquatable.GetHashCode(IEqualityComparer) IStructuralEquatable.GetHashCode(IEqualityComparer) IStructuralEquatable.GetHashCode(IEqualityComparer)

Retourne un code de hachage pour l'instance actuelle.Returns a hash code for the current instance.

Méthodes d’extension

Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable)

Effectue un cast des éléments d'un IEnumerable vers le type spécifié.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable)

Filtre les éléments d'un IEnumerable en fonction du type spécifié.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable)

Active la parallélisation d'une requête.Enables parallelization of a query.

AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable)

Convertit un IEnumerable en IQueryable.Converts an IEnumerable to an IQueryable.

S’applique à

Cohérence de thread

Les membres statiques publics (Shared dans Visual Basic) de ce type sont thread-safe.Public static (Shared in Visual Basic) members of this type are thread safe. Il n'est pas garanti que les membres d'instance soient thread-safe.Any instance members are not guaranteed to be thread safe.

Cette implémentation ne fournit pas de wrapper synchronisé (thread-safe) pour un Array; Toutefois, les classes .NET Framework basées Array sur fournissent leur propre version synchronisée de la collection à SyncRoot l’aide de la propriété.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'énumération d'une collection n'est intrinsèquement pas une procédure thread-safe.Enumerating through a collection is intrinsically not a thread-safe procedure. Même lorsqu'une collection est synchronisée, les autres threads peuvent toujours la modifier, ce qui entraîne la levée d'une exception par l'énumérateur.Even when a collection is synchronized, other threads can still modify the collection, which causes the enumerator to throw an exception. Pour garantir la sécurité des threads au cours de l’énumération, vous pouvez verrouiller la collection pendant l’ensemble de l’énumération ou bien intercepter les exceptions résultant des modifications apportées par les autres threads.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.

Voir aussi