Mise à jour : novembre 2007
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.
(dans mscorlib.dll)
Visual Basic (Déclaration)
<SerializableAttribute> _
<ComVisibleAttribute(True)> _
Public MustInherit Class Array _
Implements ICloneable, IList, ICollection, IEnumerable
Visual Basic (Utilisation)
[SerializableAttribute]
[ComVisibleAttribute(true)]
public abstract class Array : ICloneable,
IList, ICollection, IEnumerable
[SerializableAttribute]
[ComVisibleAttribute(true)]
public ref class Array abstract : ICloneable,
IList, ICollection, IEnumerable
/** @attribute SerializableAttribute */
/** @attribute ComVisibleAttribute(true) */
public abstract class Array implements ICloneable,
IList, ICollection, IEnumerable
public abstract class Array implements ICloneable, IList, ICollection, IEnumerable
La classe Array est la classe de base pour les implémentations du langage qui prennent en charge les tableaux. Cependant, seuls les compilateurs et le système peuvent dériver explicitement de la classe Array. Les utilisateurs doivent employer les constructions de tableaux fournies par le langage.
Un élément est une valeur contenue dans Array. La longueur de Array est le nombre total d'éléments qu'il peut contenir. Le rang de Array représente le nombre de dimensions dans ce Array. La limite inférieure d'une dimension de Array est l'index de départ de cette dimension de Array. Un Array multidimensionnel peut posséder différentes limites pour chaque dimension.
.gif) Remarque importante : |
|---|
Dans le .NET Framework version 2.0, la classe Array implémente les interfaces génériques System.Collections.Generic..::.IList<(Of <(T>)>), System.Collections.Generic..::.ICollection<(Of <(T>)>) et System.Collections.Generic..::.IEnumerable<(Of <(T>)>). Les implémentations sont fournies aux tableaux au moment de l'exécution et ne sont donc pas visibles pour les outils de génération de documentation. En conséquence, les interfaces génériques n'apparaissent pas dans la syntaxe de déclaration de la classe Array et il n'existe pas de rubrique de référence pour les membres d'interface qui sont uniquement accessibles en castant un tableau en type d'interface générique (implémentations d'interface explicites). Vous devez garder à l'esprit que lorsque vous castez un tableau vers l'une de ces interfaces, ces membres qui ajoutent, insèrent ou suppriment des éléments lèvent NotSupportedException. |
Les objets Type fournissent des informations sur les déclarations de type tableau. Les objets Array ayant le même type tableau partagent le même objet Type.
Il se peut que Type..::.IsArray et Type..::.GetElementType ne retournent pas les résultats attendus avec Array, car si un tableau est casté en type Array, le résultat est un objet, et non pas un tableau. Cela signifie que typeof(System.Array).IsArray retourne false et que typeof(System.Array).GetElementType retourne nullNothingnullptrune référence null (Nothing en Visual Basic).
Contrairement à la plupart des classes, Array fournit la méthode CreateInstance plutôt que des constructeurs publics, permettant ainsi l'accès à liaison tardive.
La méthode Array..::.Copy 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 le casting de type automatiquement.
Certaines méthodes, telles que CreateInstance, Copy, CopyTo, GetValue et SetValue, fournissent des surcharges qui acceptent les entiers 64 bits en tant que paramètres, afin de prendre en charge les tableaux de grande capacité. LongLength et GetLongLength retournent des entiers 64 bits indiquant la longueur du tableau.
Le tri du Array n'est pas garanti. Vous devez trier le Array avant d'exécuter des opérations (telles que BinarySearch) qui exigent le tri du Array.
L'exemple de code suivant illustre la manière dont Array..::.Copy copie des éléments entre un tableau de type entier et un tableau de type Object.
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
Overloads Public 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
Overloads Public 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
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
*/
using namespace System;
void main1();
void main2();
void main()
{
main1();
Console::WriteLine();
main2();
}
void PrintValues( array<Object^>^myArr );
void PrintValues( array<int>^myArr );
void main1()
{
// 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
*/
public class SamplesArray
{
public static void main(String[] args)
{
// Creates and initializes a new integer array and a new Object array.
int myIntArray[] = new int[] { 1, 2, 3, 4, 5 };
Object myObjArray[] = new Object[] { (Int32)26, (Int32)27, (Int32)28,
(Int32)29, (Int32)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);
} //main
public static void PrintValues(Object myArr[])
{
Object i = null;
for (int iCtr = 0; iCtr < myArr.get_Length(); iCtr++) {
i = myArr[iCtr];
Console.Write("\t{0}", i);
}
Console.WriteLine();
} //PrintValues
public static void PrintValues(int myArr[])
{
int i = 0;
for (int iCtr = 0; iCtr < myArr.get_Length(); iCtr++) {
i = myArr[iCtr];
Console.Write("\t{0}", (Int32)i);
}
Console.WriteLine();
} //PrintValues
} //SamplesArray
/*
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 Array, puis affiche ses propriétés ainsi que ses éléments.
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
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
*/
void PrintValues( Array^ myArr );
void main2()
{
// 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
*/
public class SamplesArray2
{
public static void main(String[] args)
{
// Creates and initializes a new three-dimensional Array of type Int32.
Array myArr = Array.CreateInstance(Int32.class.ToType(), 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((Int32)(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.", System.Convert.ToString(myArr.get_Rank()),
System.Convert.ToString(myArr.get_Length()));
Console.WriteLine("\tLength\tLower\tUpper");
for (int i = 0; i < myArr.get_Rank(); i++) {
Console.Write("{0}:\t{1}", System.Convert.ToString(i),
System.Convert.ToString(myArr.GetLength(i)));
Console.WriteLine("\t{0}\t{1}", System.Convert.ToString(myArr.
GetLowerBound(i)), System.Convert.ToString(myArr.
GetUpperBound(i)));
}
// Displays the contents of the Array.
Console.WriteLine("The Array contains the following values:");
PrintValues(myArr);
} //main
public static void PrintValues(Array myArr)
{
System.Collections.IEnumerator myEnumerator = myArr.GetEnumerator();
int i = 0;
int cols = myArr.GetLength(myArr.get_Rank() - 1);
while (myEnumerator.MoveNext()) {
if (i < cols) {
i++;
}
else {
Console.WriteLine();
i = 1;
}
Console.Write("\t{0}", myEnumerator.get_Current());
}
Console.WriteLine();
} //PrintValues
} //SamplesArray2
/*
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
*/
System..::.Object
System..::.Array
Les membres statiques publics (Shared en Visual Basic) de ce type sont thread-safe. Il n'est pas garanti que les membres d'instance soient thread-safe.
Cette implémentation ne fournit pas de wrapper synchronisé (thread-safe) pour un Array. Cependant, les classes .NET Framework basées sur Array fournissent leur propre version synchronisée de la collection à l'aide de la propriété SyncRoot.
L'énumération d'une collection n'est intrinsèquement pas une procédure thread-safe. Même lorsqu'une collection est synchronisée, les autres threads peuvent toujours modifier la collection, ce qui entraîne la levée d'une exception par l'énumérateur. Pour garantir la sécurité des threads au cours de l'énumération, vous pouvez soit verrouiller la collection pendant l'ensemble de l'énumération, soit intercepter les exceptions résultant des modifications apportées par les autres threads.
Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professionnel Édition x64, Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile pour Smartphone, Windows Mobile pour Pocket PC, Xbox 360
Le .NET Framework et le .NET Compact Framework ne prennent pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.
.NET Framework
Pris en charge dans : 3.5, 3.0, 2.0, 1.1, 1.0
.NET Compact Framework
Pris en charge dans : 3.5, 2.0, 1.0
XNA Framework
Pris en charge dans : 2.0, 1.0
Référence
Autres ressources