Array.Copy Método

Referencia

Definición

Espacio de nombres:: System

Ensamblado:: System.Runtime.dll

Ensamblado:: mscorlib.dll

Ensamblado:: netstandard.dll

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í.

Copia un intervalo de elementos de una matriz Array a otra Array y realiza la conversión boxing y la conversión de tipo necesarias.

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

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.

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

sourceArray: Array

Array que contiene los datos que se van a copiar.

sourceIndex: Int64

Entero de 64 bits que representa el índice de sourceArray donde comienza la copia.

destinationArray: Array

Array que recibe los datos.

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

ArgumentNullException

sourceArray es null.

O bien

destinationArray es null.

RankException

sourceArray y destinationArray tienen clasificaciones diferentes.

ArrayTypeMismatchException

sourceArray y destinationArray son de tipos incompatibles.

InvalidCastException

Al menos un elemento de la sourceArray no se puede convertir al tipo de destinationArray.

ArgumentOutOfRangeException

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.

ArgumentException

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 memmoveestá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 y destinationArray 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

sourceArray: Array

Array que contiene los datos que se van a copiar.

sourceIndex: Int32

Entero de 32 bits que representa el índice de la sourceArray en la que se empieza a copiar.

destinationArray: Array

Array que recibe los datos.

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

ArgumentNullException

sourceArray es null.

O bien

destinationArray es null.

RankException

sourceArray y destinationArray tienen clasificaciones diferentes.

ArrayTypeMismatchException

sourceArray y destinationArray son de tipos incompatibles.

InvalidCastException

Al menos un elemento de la sourceArray no se puede convertir al tipo de destinationArray.

ArgumentOutOfRangeException

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.

ArgumentException

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

[C++]

Este método es equivalente a la función memmoveestá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 y destinationArray 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 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

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.

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

sourceArray: Array

Array que contiene los datos que se van a copiar.

destinationArray: Array

Array que recibe los datos.

length: Int32

Entero de 32 bits que representa el número de elementos que se van a copiar.

Excepciones

ArgumentNullException

sourceArray es null.

O bien

destinationArray es null.

RankException

sourceArray y destinationArray tienen clasificaciones diferentes.

ArrayTypeMismatchException

sourceArray y destinationArray son de tipos incompatibles.

InvalidCastException

Al menos un elemento de la sourceArray no se puede convertir al tipo de destinationArray.

ArgumentOutOfRangeException

length es menor que cero.

ArgumentException

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

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).

[C++]

Este método es equivalente a la función memmoveestá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 y destinationArray 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 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

sourceArray: Array

Array que contiene los datos que se van a copiar.

destinationArray: Array

Array que recibe los datos.

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

ArgumentNullException

sourceArray es null.

O bien

destinationArray es null.

RankException

sourceArray y destinationArray tienen clasificaciones diferentes.

ArrayTypeMismatchException

sourceArray y destinationArray son de tipos incompatibles.

InvalidCastException

Al menos un elemento de la sourceArray no se puede convertir al tipo de destinationArray.

ArgumentOutOfRangeException

length es menor que 0 o mayor que Int32.MaxValue.

ArgumentException

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

[C++]

Este método es equivalente a la función memmoveestá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 y destinationArray 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.

Consulte también

Se aplica a

Compartir vía

Array.Copy Método

Definición

Sobrecargas

Ejemplos

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

Parámetros

Excepciones

Comentarios

Consulte también

Se aplica a

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

Parámetros

Excepciones

Comentarios

Consulte también

Se aplica a

Copy(Array, Array, Int32)

Parámetros

Excepciones

Comentarios

Consulte también

Se aplica a

Copy(Array, Array, Int64)

Parámetros

Excepciones

Comentarios

Consulte también

Se aplica a

Recursos adicionales