Array.Copy Método
Definición
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
Sobrecargas
Copy(Array, Int64, Array, Int64, Int64) |
Copia un intervalo de elementos de un objeto Array a partir del índice de origen especificado y los pega en otro objeto Array a partir del índice de destino especificado. La longitud y los índices se especifican como enteros de 64 bits. |
Copy(Array, Int32, Array, Int32, Int32) |
Copia un intervalo de elementos de un objeto Array a partir del índice de origen especificado y los pega en otro objeto Array a partir del índice de destino especificado. La longitud y los índices se especifican como enteros de 32 bits. |
Copy(Array, Array, Int32) |
Copia un intervalo de elementos de una matriz Array comenzando en el primer elemento y los pega en otra matriz Array comenzando en el primer elemento. La longitud se especifica como un entero de 32 bits. |
Copy(Array, Array, Int64) |
Copia un intervalo de elementos de una matriz Array comenzando en el primer elemento y los pega en otra matriz Array comenzando en el primer elemento. La longitud se especifica como un entero de 64 bits. |
Ejemplos
En el ejemplo de código siguiente se muestra cómo copiar de un Array tipo Object a otro Array de tipo entero.
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
Copy(Array, Int64, Array, Int64, Int64)
- 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)
Parámetros
- sourceIndex
- Int64
Entero de 64 bits que representa el índice de sourceArray
donde comienza la copia.
- destinationIndex
- Int64
Entero de 64 bits que representa el índice de destinationArray
donde comienza el almacenamiento.
- length
- Int64
Entero de 64 bits que representa el número de elementos que se van a copiar. El entero debe estar entre cero e Int32.MaxValue, ambos incluidos.
Excepciones
sourceArray
y destinationArray
tienen clasificaciones diferentes.
sourceArray
y destinationArray
son de tipos incompatibles.
Al menos un elemento de la sourceArray
no se puede convertir al tipo de destinationArray
.
sourceIndex
está fuera del intervalo de índices válidos para sourceArray
.
o bien
destinationIndex
está fuera del intervalo de índices válidos para destinationArray
.
o bien
length
es menor que 0 o mayor que Int32.MaxValue.
length
es mayor que el número de elementos desde sourceIndex
hasta el final de sourceArray
.
o bien
length
es mayor que el número de elementos desde destinationIndex
hasta el final de destinationArray
.
Comentarios
Los sourceArray
parámetros y destinationArray
deben tener el mismo número de dimensiones. Además, destinationArray
ya debe haber sido dimensionado y debe tener un número suficiente de elementos a partir de la destinationIndex
posición para acomodar los datos copiados.
Al copiar entre matrices multidimensionales, la matriz se comporta como una matriz unidimensional larga, donde las filas (o columnas) se colocan conceptualmente de un extremo a otro. Por ejemplo, si una matriz tiene tres filas (o columnas) con cuatro elementos cada uno, copiar seis elementos desde el principio de la matriz copiaría los cuatro elementos de la primera fila (o columna) y los dos primeros elementos de la segunda fila (o columna). Para empezar a copiar desde el segundo elemento de la tercera fila (o columna), sourceIndex
debe ser el límite superior de la primera fila (o columna) más la longitud de la segunda fila (o columna) más dos.
Si sourceArray
y destinationArray
se superponen, este método se comporta como si los valores originales de sourceArray
se conservaran en una ubicación temporal antes destinationArray
de sobrescribirse.
[C++]
Este método es equivalente a la función memmove
estándar de C/C++ , no memcpy
.
Las matrices pueden ser matrices de tipo referencia o matrices de tipo valor. La reducción de tipos se realiza, según sea necesario.
Al copiar desde una matriz de tipo de referencia a una matriz de tipo valor, cada elemento se desboxe y, a continuación, se copia. Al copiar desde una matriz de tipo valor a una matriz de tipo de referencia, cada elemento se conversión boxing y, a continuación, se copia.
Al copiar desde una matriz de tipo de referencia o tipo de valor a una Object matriz, se crea para Object contener cada valor o referencia y, a continuación, se copia. Al copiar de una Object matriz a una matriz de tipo referencia o de tipo valor y no es posible realizar la asignación, se produce una InvalidCastException excepción .
Si
sourceArray
ydestinationArray
son matrices de tipo de referencia o son matrices de tipo Object, se realiza una copia superficial. Una copia superficial de es Array una nueva Array que contiene referencias a los mismos elementos que el original Array. Los propios elementos o cualquier elemento al que hacen referencia los elementos no se copian. Por el contrario, una copia profunda de un copia Array los elementos y todo directamente o indirectamente al que hacen referencia los elementos.
Se produce una ArrayTypeMismatchException excepción si las matrices son de tipos incompatibles. La compatibilidad de tipos se define de la siguiente manera:
Un tipo es compatible con sí mismo.
Un tipo de valor es compatible con Object y con un tipo de interfaz implementado por ese tipo de valor. Un tipo de valor se considera conectado a una interfaz solo si implementa esa interfaz directamente. Los tipos desconectados no son compatibles.
Dos tipos de valor intrínsecos (predefinidos) son compatibles si copiar desde el tipo de origen al tipo de destino es una conversión de ampliación. Una conversión de ampliación nunca pierde información, mientras que una conversión de restricción puede perder información. Por ejemplo, convertir un entero de 32 bits con signo en un entero de 64 bits con signo es una conversión de ampliación y convertir un entero de 64 bits con signo en un entero de 32 bits con signo es una conversión de restricción. Para obtener más información sobre las conversiones, vea Convert.
Un tipo de valor nointrinsic (definido por el usuario) solo es compatible con sí mismo.
Las enumeraciones tienen una conversión implícita a Enum y a su tipo subyacente.
Si cada elemento de sourceArray
requiere una difusión a baja (por ejemplo, de una clase base a una clase derivada o de una interfaz a un objeto) y uno o varios elementos no se pueden convertir al tipo correspondiente en destinationArray
, se produce una InvalidCastException excepción .
Si este método produce una excepción durante la copia, el estado de destinationArray
no está definido.
Este método es una operación O(n
), donde n
es length
.
Consulte también
Se aplica a
Copy(Array, Int32, Array, Int32, Int32)
- 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)
Parámetros
- sourceIndex
- Int32
Entero de 32 bits que representa el índice de la sourceArray
en la que se empieza a copiar.
- destinationIndex
- Int32
Entero de 32 bits que representa el índice de la destinationArray
en la que se empieza a almacenar.
- length
- Int32
Entero de 32 bits que representa el número de elementos que se van a copiar.
Excepciones
sourceArray
y destinationArray
tienen clasificaciones diferentes.
sourceArray
y destinationArray
son de tipos incompatibles.
Al menos un elemento de la sourceArray
no se puede convertir al tipo de destinationArray
.
sourceIndex
es menor que el límite inferior de la primera dimensión de sourceArray
.
o bien
destinationIndex
es menor que el límite inferior de la primera dimensión de destinationArray
.
o bien
length
es menor que cero.
length
es mayor que el número de elementos desde sourceIndex
hasta el final de sourceArray
.
o bien
length
es mayor que el número de elementos desde destinationIndex
hasta el final de destinationArray
.
Comentarios
Los sourceArray
parámetros y destinationArray
deben tener el mismo número de dimensiones. Además, destinationArray
ya debe haber sido dimensionado y debe tener un número suficiente de elementos a partir de la destinationIndex
posición para acomodar los datos copiados.
Al copiar entre matrices multidimensionales, la matriz se comporta como una matriz unidimensional larga, donde las filas (o columnas) se colocan conceptualmente de un extremo a otro. Por ejemplo, si una matriz tiene tres filas (o columnas) con cuatro elementos cada uno, copiar seis elementos desde el principio de la matriz copiaría los cuatro elementos de la primera fila (o columna) y los dos primeros elementos de la segunda fila (o columna). Para empezar a copiar desde el segundo elemento de la tercera fila (o columna), sourceIndex
debe ser el límite superior de la primera fila (o columna) más la longitud de la segunda fila (o columna) más dos.
Si sourceArray
y destinationArray
se superponen, este método se comporta como si los valores originales de sourceArray
se conservaran en una ubicación temporal antes destinationArray
de sobrescribirse.
[C++]
Este método es equivalente a la función memmove
estándar de C/C++ , no memcpy
.
Las matrices pueden ser matrices de tipo referencia o matrices de tipo valor. La reducción de tipos se realiza, según sea necesario.
Al copiar desde una matriz de tipo de referencia a una matriz de tipo valor, cada elemento se desboxe y, a continuación, se copia. Al copiar desde una matriz de tipo valor a una matriz de tipo de referencia, cada elemento se conversión boxing y, a continuación, se copia.
Al copiar desde una matriz de tipo de referencia o tipo de valor a una Object matriz, se crea para Object contener cada valor o referencia y, a continuación, se copia. Al copiar de una Object matriz a una matriz de tipo referencia o de tipo valor y no es posible realizar la asignación, se produce una InvalidCastException excepción .
Si
sourceArray
ydestinationArray
son matrices de tipo de referencia o son matrices de tipo Object, se realiza una copia superficial. Una copia superficial de es Array una nueva Array que contiene referencias a los mismos elementos que el original Array. Los propios elementos o cualquier elemento al que hacen referencia los elementos no se copian. Por el contrario, una copia profunda de un copia Array los elementos y todo directamente o indirectamente al que hacen referencia los elementos.
Se produce una ArrayTypeMismatchException excepción si las matrices son de tipos incompatibles. La compatibilidad de tipos se define de la siguiente manera:
Un tipo es compatible con sí mismo.
Un tipo de valor es compatible con Object y con un tipo de interfaz implementado por ese tipo de valor. Un tipo de valor se considera conectado a una interfaz solo si implementa esa interfaz directamente. Los tipos desconectados no son compatibles.
Dos tipos de valor intrínsecos (predefinidos) son compatibles si copiar desde el tipo de origen al tipo de destino es una conversión de ampliación. Una conversión de ampliación nunca pierde información, mientras que una conversión de restricción puede perder información. Por ejemplo, convertir un entero de 32 bits con signo en un entero de 64 bits con signo es una conversión de ampliación y convertir un entero de 64 bits con signo en un entero de 32 bits con signo es una conversión de restricción. Para obtener más información sobre las conversiones, vea Convert.
Un tipo de valor nointrinsic (definido por el usuario) solo es compatible con sí mismo.
Las enumeraciones tienen una conversión implícita a Enum y a su tipo subyacente.
Si cada elemento de sourceArray
requiere una difusión a baja (por ejemplo, de una clase base a una clase derivada o de una interfaz a un objeto) y uno o varios elementos no se pueden convertir al tipo correspondiente en destinationArray
, se produce una InvalidCastException excepción .
Si este método produce una excepción durante la copia, el estado de destinationArray
no está definido.
Este método es una operación O(n
), donde n
es length
.
Consulte también
Se aplica a
Copy(Array, Array, Int32)
- 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)
Parámetros
- length
- Int32
Entero de 32 bits que representa el número de elementos que se van a copiar.
Excepciones
sourceArray
y destinationArray
tienen clasificaciones diferentes.
sourceArray
y destinationArray
son de tipos incompatibles.
Al menos un elemento de la sourceArray
no se puede convertir al tipo de destinationArray
.
length
es menor que cero.
length
es mayor que el número de elementos de sourceArray
.
o bien
length
es mayor que el número de elementos de destinationArray
.
Comentarios
Los sourceArray
parámetros y destinationArray
deben tener el mismo número de dimensiones. Además, destinationArray
ya debe haber sido dimensionado y debe tener un número suficiente de elementos para acomodar los datos copiados.
Al copiar entre matrices multidimensionales, la matriz se comporta como una matriz unidimensional larga, donde las filas (o columnas) se colocan conceptualmente de extremo a extremo. Por ejemplo, si una matriz tiene tres filas (o columnas) con cuatro elementos cada uno, copiar seis elementos desde el principio de la matriz copiaría los cuatro elementos de la primera fila (o columna) y los dos primeros elementos de la segunda fila (o columna).
Si sourceArray
y destinationArray
se superponen, este método se comporta como si los valores originales de sourceArray
se conservaran en una ubicación temporal antes destinationArray
de sobrescribirse.
[C++]
Este método es equivalente a la función memmove
estándar de C/C++ , no memcpy
.
Las matrices pueden ser matrices de tipo referencia o matrices de tipo valor. La reducción de tipos se realiza, según sea necesario.
Al copiar desde una matriz de tipo de referencia a una matriz de tipo valor, cada elemento se desboxe y, a continuación, se copia. Al copiar desde una matriz de tipo valor a una matriz de tipo de referencia, cada elemento se conversión boxing y, a continuación, se copia.
Al copiar desde una matriz de tipo de referencia o tipo de valor a una Object matriz, se crea para Object contener cada valor o referencia y, a continuación, se copia. Al copiar de una Object matriz a una matriz de tipo referencia o de tipo valor y no es posible realizar la asignación, se produce una InvalidCastException excepción .
Si
sourceArray
ydestinationArray
son matrices de tipo de referencia o son matrices de tipo Object, se realiza una copia superficial. Una copia superficial de es Array una nueva Array que contiene referencias a los mismos elementos que el original Array. Los propios elementos o cualquier elemento al que hacen referencia los elementos no se copian. Por el contrario, una copia profunda de un copia Array los elementos y todo directamente o indirectamente al que hacen referencia los elementos.
Se produce una ArrayTypeMismatchException excepción si las matrices son de tipos incompatibles. La compatibilidad de tipos se define de la siguiente manera:
Un tipo es compatible con sí mismo.
Un tipo de valor es compatible con Object y con un tipo de interfaz implementado por ese tipo de valor. Un tipo de valor se considera conectado a una interfaz solo si implementa esa interfaz directamente. Los tipos desconectados no son compatibles.
Dos tipos de valor intrínsecos (predefinidos) son compatibles si copiar desde el tipo de origen al tipo de destino es una conversión de ampliación. Una conversión de ampliación nunca pierde información, mientras que una conversión de restricción puede perder información. Por ejemplo, convertir un entero de 32 bits con signo en un entero de 64 bits con signo es una conversión de ampliación y convertir un entero de 64 bits con signo en un entero de 32 bits con signo es una conversión de restricción. Para obtener más información sobre las conversiones, vea Convert.
Un tipo de valor nointrinsic (definido por el usuario) solo es compatible con sí mismo.
Las enumeraciones tienen una conversión implícita a Enum y a su tipo subyacente.
Si cada elemento de sourceArray
requiere una difusión a baja (por ejemplo, de una clase base a una clase derivada o de una interfaz a un objeto) y uno o varios elementos no se pueden convertir al tipo correspondiente en destinationArray
, se produce una InvalidCastException excepción .
Si este método produce una excepción durante la copia, el estado de destinationArray
no está definido.
Este método es una operación O(n
), donde n
es length
.
Consulte también
Se aplica a
Copy(Array, Array, Int64)
- 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)
Parámetros
- length
- Int64
Entero de 64 bits que representa el número de elementos que se van a copiar. El entero debe estar entre cero e Int32.MaxValue, ambos incluidos.
Excepciones
sourceArray
y destinationArray
tienen clasificaciones diferentes.
sourceArray
y destinationArray
son de tipos incompatibles.
Al menos un elemento de la sourceArray
no se puede convertir al tipo de destinationArray
.
length
es menor que 0 o mayor que Int32.MaxValue.
length
es mayor que el número de elementos de sourceArray
.
o bien
length
es mayor que el número de elementos de destinationArray
.
Comentarios
Los sourceArray
parámetros y destinationArray
deben tener el mismo número de dimensiones. Además, destinationArray
ya debe haber sido dimensionado y debe tener un número suficiente de elementos para acomodar los datos copiados.
Al copiar entre matrices multidimensionales, la matriz se comporta como una matriz unidimensional larga, donde las filas (o columnas) se colocan conceptualmente de extremo a extremo. Por ejemplo, si una matriz tiene tres filas (o columnas) con cuatro elementos cada uno, copiar seis elementos desde el principio de la matriz copiaría los cuatro elementos de la primera fila (o columna) y los dos primeros elementos de la segunda fila (o columna).
Si sourceArray
y destinationArray
se superponen, este método se comporta como si los valores originales de sourceArray
se conservaran en una ubicación temporal antes destinationArray
de sobrescribirse.
[C++]
Este método es equivalente a la función memmove
estándar de C/C++ , no memcpy
.
Las matrices pueden ser matrices de tipo referencia o matrices de tipo valor. La reducción de tipos se realiza, según sea necesario.
Al copiar desde una matriz de tipo de referencia a una matriz de tipo valor, cada elemento se desboxe y, a continuación, se copia. Al copiar desde una matriz de tipo valor a una matriz de tipo de referencia, cada elemento se conversión boxing y, a continuación, se copia.
Al copiar desde una matriz de tipo de referencia o tipo de valor a una Object matriz, se crea para Object contener cada valor o referencia y, a continuación, se copia. Al copiar de una Object matriz a una matriz de tipo de referencia o de tipo valor y la asignación no es posible, se produce una InvalidCastException excepción .
Si
sourceArray
ydestinationArray
son matrices de tipo de referencia o son matrices de tipo Object, se realiza una copia superficial. Una copia superficial de un Array objeto es una nueva Array que contiene referencias a los mismos elementos que el original Array. Los propios elementos o cualquier cosa a la que hacen referencia los elementos no se copian. Por el contrario, una copia profunda de un Array copia los elementos y todo lo que hace referencia directa o indirectamente por los elementos.
Se produce una excepción ArrayTypeMismatchException si las matrices son de tipos incompatibles. La compatibilidad de tipos se define de la siguiente manera:
Un tipo es compatible con sí mismo.
Un tipo de valor es compatible con Object y con un tipo de interfaz implementado por ese tipo de valor. Un tipo de valor se considera conectado a una interfaz solo si implementa esa interfaz directamente. Los tipos desconectados no son compatibles.
Dos tipos de valor intrínsecos (predefinidos) son compatibles si copiar desde el tipo de origen al tipo de destino es una conversión de ampliación. Una conversión de ampliación nunca pierde información, mientras que una conversión de restricción puede perder información. Por ejemplo, convertir un entero de 32 bits con signo en un entero de 64 bits con signo es una conversión de ampliación y convertir un entero de 64 bits con signo en un entero de 32 bits con signo es una conversión de restricción. Para obtener más información sobre las conversiones, vea Convert.
Un tipo de valor nointrinsic (definido por el usuario) solo es compatible con sí mismo.
Las enumeraciones tienen una conversión implícita a Enum y a su tipo subyacente.
Si cada elemento de sourceArray
requiere una difusión vertical (por ejemplo, de una clase base a una clase derivada o de una interfaz a un objeto) y uno o varios elementos no se pueden convertir al tipo correspondiente de destinationArray
, se produce una InvalidCastException excepción .
Si este método produce una excepción mientras se copia, el estado de destinationArray
no está definido.
Este método es una operación O(n
), donde n
es length
.