Array.Copy Método

Definición

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

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

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

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

sourceArray es null.

O bien

destinationArray es null.

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 dar cabida a 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, al copiar seis elementos desde el principio de la matriz se copiarán 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 memmoveestándar de C/C++ , no memcpya .

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

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.

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

sourceArray es null.

O bien

destinationArray es null.

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 dar cabida a 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 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)

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.

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

sourceArray es null.

O bien

destinationArray es null.

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

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

sourceArray es null.

O bien

destinationArray es null.

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