Array.Copy Méthode
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
Copy(Array, Int64, Array, Int64, Int64) |
Copie une plage d’éléments à partir d’un Array commençant à l’index source spécifié et les colle dans un autre Array commençant à l’index de destination spécifié. La longueur et les index sont spécifiés en tant qu’entiers 64 bits. |
Copy(Array, Int32, Array, Int32, Int32) |
Copie une plage d’éléments à partir d’un Array commençant à l’index source spécifié et les colle dans un autre Array commençant à l’index de destination spécifié. La longueur et les index sont spécifiés en tant qu’entiers 32 bits. |
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. La longueur est spécifiée sous forme d'un entier 32 bits. |
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. La longueur est spécifiée sous forme d'un entier 64 bits. |
L’exemple de code suivant montre comment copier d’un Array type Object vers un autre Array de type entier.
using namespace System;
void PrintValues( Array^ myArr );
void main()
{
// Creates and initializes a new Array instance of type Int32.
Array^ myIntArray = Array::CreateInstance( Type::GetType( "System.Int32" ), 5 );
for ( int i = myIntArray->GetLowerBound( 0 ); i <= myIntArray->GetUpperBound( 0 ); i++ )
myIntArray->SetValue( i + 1, i );
// Creates and initializes a new Array instance of type Object.
Array^ myObjArray = Array::CreateInstance( Type::GetType( "System.Object" ), 5 );
for ( int i = myObjArray->GetLowerBound( 0 ); i <= myObjArray->GetUpperBound( 0 ); i++ )
myObjArray->SetValue( i + 26, i );
// Displays the initial values of both arrays.
Console::WriteLine( "Int32 array:" );
PrintValues( myIntArray );
Console::WriteLine( "Object array:" );
PrintValues( myObjArray );
// Copies the first element from the Int32 array to the Object array.
Array::Copy( myIntArray, myIntArray->GetLowerBound( 0 ), myObjArray, myObjArray->GetLowerBound( 0 ), 1 );
// Copies the last two elements from the Object array to the Int32 array.
Array::Copy( myObjArray, myObjArray->GetUpperBound( 0 ) - 1, myIntArray, myIntArray->GetUpperBound( 0 ) - 1, 2 );
// Displays the values of the modified arrays.
Console::WriteLine( "Int32 array - Last two elements should now be the same as Object array:" );
PrintValues( myIntArray );
Console::WriteLine( "Object array - First element should now be the same as Int32 array:" );
PrintValues( myObjArray );
}
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.
Int32 array:
1 2 3 4 5
Object array:
26 27 28 29 30
Int32 array - Last two elements should now be the same as Object array:
1 2 3 29 30
Object array - First element should now be the same as Int32 array:
1 27 28 29 30
*/
open System
let printValues (myArr: 'a []) =
let mutable i = 0;
let cols = myArr.GetLength(myArr.Rank - 1)
for item in myArr do
if i < cols then
i <- i + 1
else
printfn ""
i <- 1
printf $"\t{item}"
printfn ""
// Creates and initializes a new Array of type int.
let myIntArray = [| 1..5 |]
// Creates and initializes a new Array of type Object.
let myObjArray = Array.init 5 (fun i -> i + 26 :> obj)
// Displays the initial values of both arrays.
printfn "int array:"
printValues myIntArray
printfn "Object array:"
printValues myObjArray
// Copies the first element from the int array to the Object array.
Array.Copy(myIntArray, myIntArray.GetLowerBound 0, myObjArray, myObjArray.GetLowerBound 0, 1)
// Copies the last two elements from the Object array to the int array.
Array.Copy(myObjArray, myObjArray.GetUpperBound 0 - 1, myIntArray, myIntArray.GetUpperBound 0 - 1, 2)
// Displays the values of the modified arrays.
printfn "int array - Last two elements should now be the same as Object array:"
printValues myIntArray
printfn "Object array - First element should now be the same as int array:"
printValues myObjArray
// This code produces the following output.
// int array:
// 1 2 3 4 5
// Object array:
// 26 27 28 29 30
// int array - Last two elements should now be the same as Object array:
// 1 2 3 29 30
// Object array - First element should now be the same as int array:
// 1 27 28 29 30
using System;
public class SamplesArray {
public static void Main() {
// Creates and initializes a new Array of type int.
Array myIntArray=Array.CreateInstance( typeof(System.Int32), 5 );
for ( int i = myIntArray.GetLowerBound(0); i <= myIntArray.GetUpperBound(0); i++ )
myIntArray.SetValue( i+1, i );
// Creates and initializes a new Array of type Object.
Array myObjArray = Array.CreateInstance( typeof(System.Object), 5 );
for ( int i = myObjArray.GetLowerBound(0); i <= myObjArray.GetUpperBound(0); i++ )
myObjArray.SetValue( i+26, i );
// Displays the initial values of both arrays.
Console.WriteLine( "int array:" );
PrintValues( myIntArray );
Console.WriteLine( "Object array:" );
PrintValues( myObjArray );
// Copies the first element from the int array to the Object array.
Array.Copy( myIntArray, myIntArray.GetLowerBound(0), myObjArray, myObjArray.GetLowerBound(0), 1 );
// Copies the last two elements from the Object array to the int array.
Array.Copy( myObjArray, myObjArray.GetUpperBound(0) - 1, myIntArray, myIntArray.GetUpperBound(0) - 1, 2 );
// Displays the values of the modified arrays.
Console.WriteLine( "int array - Last two elements should now be the same as Object array:" );
PrintValues( myIntArray );
Console.WriteLine( "Object array - First element should now be the same as int array:" );
PrintValues( myObjArray );
}
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.
int array:
1 2 3 4 5
Object array:
26 27 28 29 30
int array - Last two elements should now be the same as Object array:
1 2 3 29 30
Object array - First element should now be the same as int array:
1 27 28 29 30
*/
Public Class SamplesArray
Public Shared Sub Main()
' Creates and initializes a new Array of type Int32.
Dim myIntArray As Array = _
Array.CreateInstance(GetType(System.Int32), 5)
Dim i As Integer
For i = myIntArray.GetLowerBound(0) To myIntArray.GetUpperBound(0)
myIntArray.SetValue(i + 1, i)
Next i
' Creates and initializes a new Array of type Object.
Dim myObjArray As Array = _
Array.CreateInstance(GetType(System.Object), 5)
For i = myObjArray.GetLowerBound(0) To myObjArray.GetUpperBound(0)
myObjArray.SetValue(i + 26, i)
Next i
' Displays the initial values of both arrays.
Console.WriteLine("Int32 array:")
PrintValues(myIntArray)
Console.WriteLine("Object array:")
PrintValues(myObjArray)
' Copies the first element from the Int32 array to the Object array.
Array.Copy(myIntArray, myIntArray.GetLowerBound(0), myObjArray, _
myObjArray.GetLowerBound(0), 1)
' Copies the last two elements from the Object array to the Int32 array.
Array.Copy(myObjArray, myObjArray.GetUpperBound(0) - 1, myIntArray, _
myIntArray.GetUpperBound(0) - 1, 2)
' Displays the values of the modified arrays.
Console.WriteLine("Int32 array - Last two elements should now be " _
+ "the same as Object array:")
PrintValues(myIntArray)
Console.WriteLine("Object array - First element should now be the " _
+ "same as Int32 array:")
PrintValues(myObjArray)
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.
'
' Int32 array:
' 1 2 3 4 5
' Object array:
' 26 27 28 29 30
' Int32 array - Last two elements should now be the same as Object array:
' 1 2 3 29 30
' Object array - First element should now be the same as Int32 array:
' 1 27 28 29 30
- Source:
- Array.cs
- Source:
- Array.cs
- Source:
- Array.cs
public:
static void Copy(Array ^ sourceArray, long sourceIndex, Array ^ destinationArray, long destinationIndex, long length);
public static void Copy (Array sourceArray, long sourceIndex, Array destinationArray, long destinationIndex, long length);
static member Copy : Array * int64 * Array * int64 * int64 -> unit
Public Shared Sub Copy (sourceArray As Array, sourceIndex As Long, destinationArray As Array, destinationIndex As Long, length As Long)
Paramètres
- sourceIndex
- Int64
Entier 64 bits qui représente l’index du sourceArray
auquel la copie commence.
- destinationIndex
- Int64
Entier 64 bits qui représente l’index du destinationArray
auquel le stockage commence.
- length
- Int64
Entier 64 bits qui représente le nombre d’éléments à copier. L’entier doit être compris entre zéro et Int32.MaxValue, inclus.
Exceptions
sourceArray
et destinationArray
ont des classements différents.
sourceArray
et destinationArray
sont de types incompatibles.
Au moins un élément de sourceArray
ne peut pas être converti en type destinationArray
.
sourceIndex
est en dehors de la plage d’index valides pour sourceArray
.
- ou -
destinationIndex
est en dehors de la plage d’index valides pour destinationArray
.
- ou -
length
est inférieur à 0 ou supérieur à Int32.MaxValue.
length
est supérieur au nombre d’éléments compris entre sourceIndex
et la fin de sourceArray
.
- ou -
length
est supérieur au nombre d’éléments compris entre destinationIndex
et la fin de destinationArray
.
Remarques
Les sourceArray
paramètres et destinationArray
doivent avoir le même nombre de dimensions. En outre, destinationArray
doit déjà avoir été dimensionné et avoir un nombre suffisant d’éléments à partir de la destinationIndex
position pour prendre en charge les données copiées.
Lors de la copie entre des tableaux multidimensionnels, le tableau se comporte comme un long tableau unidimensionnel, où les lignes (ou colonnes) sont conceptuellement disposées de bout en bout. Par exemple, si un tableau a trois lignes (ou colonnes) avec quatre éléments chacune, la copie de six éléments à partir du début du tableau copierait les quatre éléments de la première ligne (ou colonne) et les deux premiers éléments de la deuxième ligne (ou colonne). Pour commencer à copier à partir du deuxième élément de la troisième ligne (ou colonne), sourceIndex
doit être la limite supérieure de la première ligne (ou colonne) plus la longueur de la deuxième ligne (ou colonne) plus deux.
Si sourceArray
et destinationArray
se chevauchent, cette méthode se comporte comme si les valeurs d’origine de sourceArray
avaient été conservées dans un emplacement temporaire avant destinationArray
d’être remplacées.
[C++]
Cette méthode équivaut à la fonction memmove
C/C++ standard , et non memcpy
à .
Les tableaux peuvent être des tableaux de type référence ou des tableaux de type valeur. La conversion de type est effectuée, en fonction des besoins.
Lors de la copie d’un tableau de type référence vers un tableau de type valeur, chaque élément est unboxed, puis copié. Lors de la copie d’un tableau de type valeur vers un tableau de type référence, chaque élément est encadré, puis copié.
Lors de la copie d’un tableau de type référence ou de type valeur vers un Object tableau, un Object est créé pour contenir chaque valeur ou référence, puis copié. Lors de la copie d’un Object tableau vers un tableau de type référence ou de type valeur et que l’affectation n’est pas possible, un InvalidCastException est levée.
Si
sourceArray
etdestinationArray
sont des tableaux de type référence ou sont tous deux des tableaux de type Object, une copie superficielle est effectuée. Une copie superficielle d’un Array est une nouvelle Array contenant des références aux mêmes éléments que l’original Array. Les éléments eux-mêmes ou tout ce qui est référencé par les éléments ne sont pas copiés. En revanche, une copie approfondie d’une Array copie copie les éléments et tout ce qui est référencé directement ou indirectement par les éléments.
Un ArrayTypeMismatchException est levée si les tableaux sont de types incompatibles. La compatibilité de type est définie comme suit :
Un type est compatible avec lui-même.
Un type valeur est compatible avec Object et avec un type d’interface implémenté par ce type de valeur. Un type de valeur est considéré comme connecté à une interface uniquement s’il implémente cette interface directement. Les types déconnectés ne sont pas compatibles.
Deux types de valeurs intrinsèques (prédéfinis) sont compatibles si la copie du type source vers le type de destination est une conversion étendue. Une conversion élargie ne perd jamais d’informations, tandis qu’une conversion restrictive peut perdre des informations. Par exemple, la conversion d’un entier signé 32 bits en entier signé 64 bits est une conversion étendue, et la conversion d’un entier signé 64 bits en entier signé 32 bits est une conversion restrictive. Pour plus d’informations sur les conversions, consultez Convert.
Un type de valeur nonintrinsique (défini par l’utilisateur) n’est compatible qu’avec lui-même.
Les énumérations ont une conversion implicite vers Enum et vers leur type sous-jacent.
Si chaque élément dans sourceArray
nécessite un downcast (par exemple, d’une classe de base à une classe dérivée ou d’une interface vers un objet) et qu’un ou plusieurs éléments ne peuvent pas être castés en type correspondant dans destinationArray
, un InvalidCastException est levée.
Si cette méthode lève une exception lors de la copie, l’état de destinationArray
n’est pas défini.
Cette méthode est une opération O(n
), où n
est length
.
Voir aussi
S’applique à
.NET 9 et autres versions
Produit | Versions |
---|---|
.NET | Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 2.0, 2.1 |
- Source:
- Array.CoreCLR.cs
- Source:
- Array.cs
- Source:
- Array.cs
public:
static void Copy(Array ^ sourceArray, int sourceIndex, Array ^ destinationArray, int destinationIndex, int length);
public static void Copy (Array sourceArray, int sourceIndex, Array destinationArray, int destinationIndex, int length);
static member Copy : Array * int * Array * int * int -> unit
Public Shared Sub Copy (sourceArray As Array, sourceIndex As Integer, destinationArray As Array, destinationIndex As Integer, length As Integer)
Paramètres
- sourceIndex
- Int32
Entier 32 bits qui représente l’index du sourceArray
auquel la copie commence.
- destinationIndex
- Int32
Entier 32 bits qui représente l’index du destinationArray
auquel le stockage commence.
- length
- Int32
Entier 32 bits qui représente le nombre d'éléments à copier.
Exceptions
sourceArray
et destinationArray
ont des classements différents.
sourceArray
et destinationArray
sont de types incompatibles.
Au moins un élément de sourceArray
ne peut pas être converti en type destinationArray
.
sourceIndex
est inférieur à la limite inférieure de la première dimension de sourceArray
.
- ou -
destinationIndex
est inférieur à la limite inférieure de la première dimension de destinationArray
.
- ou -
length
est inférieur à zéro.
length
est supérieur au nombre d’éléments compris entre sourceIndex
et la fin de sourceArray
.
- ou -
length
est supérieur au nombre d’éléments compris entre destinationIndex
et la fin de destinationArray
.
Remarques
Les sourceArray
paramètres et destinationArray
doivent avoir le même nombre de dimensions. En outre, destinationArray
doit déjà avoir été dimensionné et avoir un nombre suffisant d’éléments à partir de la destinationIndex
position pour prendre en charge les données copiées.
Lors de la copie entre des tableaux multidimensionnels, le tableau se comporte comme un long tableau unidimensionnel, où les lignes (ou colonnes) sont conceptuellement disposées de bout en bout. Par exemple, si un tableau a trois lignes (ou colonnes) avec quatre éléments chacune, la copie de six éléments à partir du début du tableau copierait les quatre éléments de la première ligne (ou colonne) et les deux premiers éléments de la deuxième ligne (ou colonne). Pour commencer à copier à partir du deuxième élément de la troisième ligne (ou colonne), sourceIndex
doit être la limite supérieure de la première ligne (ou colonne) plus la longueur de la deuxième ligne (ou colonne) plus deux.
Si sourceArray
et destinationArray
se chevauchent, cette méthode se comporte comme si les valeurs d’origine de sourceArray
avaient été conservées dans un emplacement temporaire avant destinationArray
d’être remplacées.
[C++]
Cette méthode équivaut à la fonction memmove
C/C++ standard , et non memcpy
à .
Les tableaux peuvent être des tableaux de type référence ou des tableaux de type valeur. La conversion de type est effectuée, en fonction des besoins.
Lors de la copie d’un tableau de type référence vers un tableau de type valeur, chaque élément est unboxed, puis copié. Lors de la copie d’un tableau de type valeur vers un tableau de type référence, chaque élément est encadré, puis copié.
Lors de la copie d’un tableau de type référence ou de type valeur vers un Object tableau, un Object est créé pour contenir chaque valeur ou référence, puis copié. Lors de la copie d’un Object tableau vers un tableau de type référence ou de type valeur et que l’affectation n’est pas possible, un InvalidCastException est levée.
Si
sourceArray
etdestinationArray
sont des tableaux de type référence ou sont tous deux des tableaux de type Object, une copie superficielle est effectuée. Une copie superficielle d’un Array est une nouvelle Array contenant des références aux mêmes éléments que l’original Array. Les éléments eux-mêmes ou tout ce qui est référencé par les éléments ne sont pas copiés. En revanche, une copie approfondie d’une Array copie copie les éléments et tout ce qui est référencé directement ou indirectement par les éléments.
Un ArrayTypeMismatchException est levée si les tableaux sont de types incompatibles. La compatibilité de type est définie comme suit :
Un type est compatible avec lui-même.
Un type valeur est compatible avec Object et avec un type d’interface implémenté par ce type de valeur. Un type de valeur est considéré comme connecté à une interface uniquement s’il implémente cette interface directement. Les types déconnectés ne sont pas compatibles.
Deux types de valeurs intrinsèques (prédéfinis) sont compatibles si la copie du type source vers le type de destination est une conversion étendue. Une conversion élargie ne perd jamais d’informations, tandis qu’une conversion restrictive peut perdre des informations. Par exemple, la conversion d’un entier signé 32 bits en entier signé 64 bits est une conversion étendue, et la conversion d’un entier signé 64 bits en entier signé 32 bits est une conversion restrictive. Pour plus d’informations sur les conversions, consultez Convert.
Un type de valeur nonintrinsique (défini par l’utilisateur) n’est compatible qu’avec lui-même.
Les énumérations ont une conversion implicite vers Enum et vers leur type sous-jacent.
Si chaque élément dans sourceArray
nécessite un downcast (par exemple, d’une classe de base à une classe dérivée ou d’une interface vers un objet) et qu’un ou plusieurs éléments ne peuvent pas être castés en type correspondant dans destinationArray
, un InvalidCastException est levée.
Si cette méthode lève une exception lors de la copie, l’état de destinationArray
n’est pas défini.
Cette méthode est une opération O(n
), où n
est length
.
Voir aussi
S’applique à
.NET 9 et autres versions
Produit | Versions |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
- Source:
- Array.CoreCLR.cs
- Source:
- Array.cs
- Source:
- Array.cs
public:
static void Copy(Array ^ sourceArray, Array ^ destinationArray, int length);
public static void Copy (Array sourceArray, Array destinationArray, int length);
static member Copy : Array * Array * int -> unit
Public Shared Sub Copy (sourceArray As Array, destinationArray As Array, length As Integer)
Paramètres
- length
- Int32
Entier 32 bits qui représente le nombre d'éléments à copier.
Exceptions
sourceArray
et destinationArray
ont des classements différents.
sourceArray
et destinationArray
sont de types incompatibles.
Au moins un élément de sourceArray
ne peut pas être converti en type destinationArray
.
length
est inférieur à zéro.
length
est supérieur au nombre d’éléments de sourceArray
.
- ou -
length
est supérieur au nombre d’éléments de destinationArray
.
Remarques
Les sourceArray
paramètres et destinationArray
doivent avoir le même nombre de dimensions. En outre, destinationArray
doit déjà avoir été dimensionné et avoir un nombre suffisant d’éléments pour prendre en charge les données copiées.
Lors de la copie entre des tableaux multidimensionnels, le tableau se comporte comme un long tableau unidimensionnel, où les lignes (ou colonnes) sont conceptuellement disposées de bout en bout. Par exemple, si un tableau a trois lignes (ou colonnes) avec quatre éléments chacune, la copie de six éléments à partir du début du tableau copierait les quatre éléments de la première ligne (ou colonne) et les deux premiers éléments de la deuxième ligne (ou colonne).
Si sourceArray
et destinationArray
se chevauchent, cette méthode se comporte comme si les valeurs d’origine de sourceArray
avaient été conservées dans un emplacement temporaire avant destinationArray
d’être remplacées.
[C++]
Cette méthode équivaut à la fonction memmove
C/C++ standard , et non memcpy
à .
Les tableaux peuvent être des tableaux de type référence ou des tableaux de type valeur. La conversion de type est effectuée, en fonction des besoins.
Lors de la copie d’un tableau de type référence vers un tableau de type valeur, chaque élément est unboxed, puis copié. Lors de la copie d’un tableau de type valeur vers un tableau de type référence, chaque élément est encadré, puis copié.
Lors de la copie d’un tableau de type référence ou de type valeur vers un Object tableau, un Object est créé pour contenir chaque valeur ou référence, puis copié. Lors de la copie d’un Object tableau vers un tableau de type référence ou de type valeur et que l’affectation n’est pas possible, un InvalidCastException est levée.
Si
sourceArray
etdestinationArray
sont des tableaux de type référence ou sont tous deux des tableaux de type Object, une copie superficielle est effectuée. Une copie superficielle d’un Array est une nouvelle Array contenant des références aux mêmes éléments que l’original Array. Les éléments eux-mêmes ou tout ce qui est référencé par les éléments ne sont pas copiés. En revanche, une copie approfondie d’une Array copie copie les éléments et tout ce qui est référencé directement ou indirectement par les éléments.
Un ArrayTypeMismatchException est levée si les tableaux sont de types incompatibles. La compatibilité de type est définie comme suit :
Un type est compatible avec lui-même.
Un type valeur est compatible avec Object et avec un type d’interface implémenté par ce type de valeur. Un type de valeur est considéré comme connecté à une interface uniquement s’il implémente cette interface directement. Les types déconnectés ne sont pas compatibles.
Deux types de valeurs intrinsèques (prédéfinis) sont compatibles si la copie du type source vers le type de destination est une conversion étendue. Une conversion élargie ne perd jamais d’informations, tandis qu’une conversion restrictive peut perdre des informations. Par exemple, la conversion d’un entier signé 32 bits en entier signé 64 bits est une conversion étendue, et la conversion d’un entier signé 64 bits en entier signé 32 bits est une conversion restrictive. Pour plus d’informations sur les conversions, consultez Convert.
Un type de valeur nonintrinsique (défini par l’utilisateur) n’est compatible qu’avec lui-même.
Les énumérations ont une conversion implicite vers Enum et vers leur type sous-jacent.
Si chaque élément dans sourceArray
nécessite un downcast (par exemple, d’une classe de base à une classe dérivée ou d’une interface vers un objet) et qu’un ou plusieurs éléments ne peuvent pas être castés en type correspondant dans destinationArray
, un InvalidCastException est levée.
Si cette méthode lève une exception lors de la copie, l’état de destinationArray
n’est pas défini.
Cette méthode est une opération O(n
), où n
est length
.
Voir aussi
S’applique à
.NET 9 et autres versions
Produit | Versions |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
- Source:
- Array.cs
- Source:
- Array.cs
- Source:
- Array.cs
public:
static void Copy(Array ^ sourceArray, Array ^ destinationArray, long length);
public static void Copy (Array sourceArray, Array destinationArray, long length);
static member Copy : Array * Array * int64 -> unit
Public Shared Sub Copy (sourceArray As Array, destinationArray As Array, length As Long)
Paramètres
- length
- Int64
Entier 64 bits qui représente le nombre d’éléments à copier. L’entier doit être compris entre zéro et Int32.MaxValue, inclus.
Exceptions
sourceArray
et destinationArray
ont des classements différents.
sourceArray
et destinationArray
sont de types incompatibles.
Au moins un élément de sourceArray
ne peut pas être converti en type destinationArray
.
length
est inférieur à 0 ou supérieur à Int32.MaxValue.
length
est supérieur au nombre d’éléments de sourceArray
.
- ou -
length
est supérieur au nombre d’éléments de destinationArray
.
Remarques
Les sourceArray
paramètres et destinationArray
doivent avoir le même nombre de dimensions. En outre, destinationArray
doit déjà avoir été dimensionné et avoir un nombre suffisant d’éléments pour prendre en charge les données copiées.
Lors de la copie entre des tableaux multidimensionnels, le tableau se comporte comme un long tableau unidimensionnel, où les lignes (ou colonnes) sont conceptuellement disposées de bout en bout. Par exemple, si un tableau a trois lignes (ou colonnes) avec quatre éléments chacune, la copie de six éléments à partir du début du tableau copierait les quatre éléments de la première ligne (ou colonne) et les deux premiers éléments de la deuxième ligne (ou colonne).
Si sourceArray
et destinationArray
se chevauchent, cette méthode se comporte comme si les valeurs d’origine de sourceArray
avaient été conservées dans un emplacement temporaire avant destinationArray
d’être remplacées.
[C++]
Cette méthode équivaut à la fonction memmove
C/C++ standard , et non memcpy
à .
Les tableaux peuvent être des tableaux de type référence ou des tableaux de type valeur. La conversion de type est effectuée, en fonction des besoins.
Lors de la copie d’un tableau de type référence vers un tableau de type valeur, chaque élément est unboxed, puis copié. Lors de la copie d’un tableau de type valeur vers un tableau de type référence, chaque élément est encadré, puis copié.
Lors de la copie d’un tableau de type référence ou de type valeur vers un Object tableau, un Object est créé pour contenir chaque valeur ou référence, puis copié. Lors de la copie d’un Object tableau vers un tableau de type référence ou de type valeur et que l’affectation n’est pas possible, un InvalidCastException est levée.
Si
sourceArray
etdestinationArray
sont des tableaux de type référence ou sont tous deux des tableaux de type Object, une copie superficielle est effectuée. Une copie superficielle d’un Array est une nouvelle Array contenant des références aux mêmes éléments que l’original Array. Les éléments eux-mêmes ou tout ce qui est référencé par les éléments ne sont pas copiés. En revanche, une copie approfondie d’une Array copie copie les éléments et tout ce qui est référencé directement ou indirectement par les éléments.
Un ArrayTypeMismatchException est levée si les tableaux sont de types incompatibles. La compatibilité de type est définie comme suit :
Un type est compatible avec lui-même.
Un type valeur est compatible avec Object et avec un type d’interface implémenté par ce type de valeur. Un type de valeur est considéré comme connecté à une interface uniquement s’il implémente cette interface directement. Les types déconnectés ne sont pas compatibles.
Deux types de valeurs intrinsèques (prédéfinis) sont compatibles si la copie du type source vers le type de destination est une conversion étendue. Une conversion élargie ne perd jamais d’informations, tandis qu’une conversion restrictive peut perdre des informations. Par exemple, la conversion d’un entier signé 32 bits en entier signé 64 bits est une conversion étendue, et la conversion d’un entier signé 64 bits en entier signé 32 bits est une conversion restrictive. Pour plus d’informations sur les conversions, consultez Convert.
Un type de valeur nonintrinsique (défini par l’utilisateur) n’est compatible qu’avec lui-même.
Les énumérations ont une conversion implicite vers Enum et vers leur type sous-jacent.
Si chaque élément dans sourceArray
nécessite un downcast (par exemple, d’une classe de base à une classe dérivée ou d’une interface vers un objet) et qu’un ou plusieurs éléments ne peuvent pas être castés en type correspondant dans destinationArray
, un InvalidCastException est levée.
Si cette méthode lève une exception lors de la copie, l’état de destinationArray
n’est pas défini.
Cette méthode est une opération O(n
), où n
est length
.
Voir aussi
S’applique à
.NET 9 et autres versions
Produit | Versions |
---|---|
.NET | Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 2.0, 2.1 |
Commentaires sur .NET
.NET est un projet open source. Sélectionnez un lien pour fournir des commentaires :