Array.Copy Array.Copy Array.Copy Array.Copy Method

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.Copies a range of elements in one Array to another Array and performs type casting and boxing as required.

Sobrecargas

Copy(Array, Int64, Array, Int64, Int64) Copy(Array, Int64, Array, Int64, Int64) Copy(Array, Int64, Array, Int64, Int64) 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.Copies a range of elements from an Array starting at the specified source index and pastes them to another Array starting at the specified destination index. La longitud y los índices se especifican como enteros de 64 bits.The length and the indexes are specified as 64-bit integers.

Copy(Array, Int32, Array, Int32, Int32) Copy(Array, Int32, Array, Int32, Int32) Copy(Array, Int32, Array, Int32, Int32) 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.Copies a range of elements from an Array starting at the specified source index and pastes them to another Array starting at the specified destination index. La longitud y los índices se especifican como enteros de 32 bits.The length and the indexes are specified as 32-bit integers.

Copy(Array, Array, Int64) Copy(Array, Array, Int64) Copy(Array, Array, Int64) 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.Copies a range of elements from an Array starting at the first element and pastes them into another Array starting at the first element. La longitud se especifica como un entero de 64 bits.The length is specified as a 64-bit integer.

Copy(Array, Array, Int32) Copy(Array, Array, Int32) Copy(Array, Array, Int32) 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.Copies a range of elements from an Array starting at the first element and pastes them into another Array starting at the first element. La longitud se especifica como un entero de 32 bits.The length is specified as a 32-bit integer.

Copy(Array, Int64, Array, Int64, Int64) Copy(Array, Int64, Array, Int64, Int64) Copy(Array, Int64, Array, Int64, Int64) 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.Copies a range of elements from an Array starting at the specified source index and pastes them to another Array starting at the specified destination index. La longitud y los índices se especifican como enteros de 64 bits.The length and the indexes are specified as 64-bit integers.

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

Array que contiene los datos que se van a copiar.The Array that contains the data to copy.

sourceIndex
Int64 Int64 Int64 Int64

Entero de 64 bits que representa el índice de sourceArray donde comienza la copia.A 64-bit integer that represents the index in the sourceArray at which copying begins.

destinationArray
Array Array Array Array

Array que recibe los datos.The Array that receives the data.

destinationIndex
Int64 Int64 Int64 Int64

Entero de 64 bits que representa el índice de destinationArray donde comienza el almacenamiento.A 64-bit integer that represents the index in the destinationArray at which storing begins.

length
Int64 Int64 Int64 Int64

Entero de 64 bits que representa el número de elementos que se van a copiar.A 64-bit integer that represents the number of elements to copy. El entero debe estar entre cero y MaxValue, ambos inclusive.The integer must be between zero and MaxValue, inclusive.

Excepciones

El valor de sourceArray es null.sourceArray is null.

-o bien--or- El valor de destinationArray es null.destinationArray is null.

sourceArray y destinationArray tienen clasificaciones diferentes.sourceArray and destinationArray have different ranks.

sourceArray y destinationArray son de tipos incompatibles.sourceArray and destinationArray are of incompatible types.

Al menos un elemento de sourceArray no se puede convertir al tipo de destinationArray.At least one element in sourceArray cannot be cast to the type of destinationArray.

sourceIndex está fuera del intervalo de índices válidos para sourceArray.sourceIndex is outside the range of valid indexes for the sourceArray.

-o bien--or- destinationIndex está fuera del intervalo de índices válidos para destinationArray.destinationIndex is outside the range of valid indexes for the destinationArray.

-o bien--or- length es menor que 0 o mayor que MaxValue.length is less than 0 or greater than MaxValue.

length es mayor que el número de elementos desde sourceIndex hasta el final de sourceArray.length is greater than the number of elements from sourceIndex to the end of sourceArray.

-o bien--or- length es mayor que el número de elementos desde destinationIndex hasta el final de destinationArray.length is greater than the number of elements from destinationIndex to the end of destinationArray.

Ejemplos

El ejemplo de código siguiente muestra cómo copiar desde una Array typu Object a otro Array de tipo entero.The following code example shows how to copy from one Array of type Object to another Array of type integer.

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
 */
using System;
public class SamplesArray  {

   public static void Main()  {

      // Creates and initializes a new Array of type Int32.
      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( "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 );
   }


   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.

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
*/
Imports System
Imports Microsoft.VisualBasic

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

Comentarios

El sourceArray y destinationArray parámetros deben tener el mismo número de dimensiones.The sourceArray and destinationArray parameters must have the same number of dimensions. Además, destinationArray debe ya han dimensionada y debe tener un número suficiente de elementos a partir de la destinationIndex posición para dar cabida a los datos copiados.In addition, destinationArray must already have been dimensioned and must have a sufficient number of elements starting from the destinationIndex position to accommodate the copied data.

Al copiar datos entre las matrices multidimensionales, la matriz se comporta como una matriz unidimensional larga, donde las filas (o columnas) se distribuyen conceptualmente-to-end.When copying between multidimensional arrays, the array behaves like a long one-dimensional array, where the rows (or columns) are conceptually laid end-to-end. Por ejemplo, si una matriz tiene tres filas (o columnas) con cuatro elementos cada uno, copian seis elementos desde el principio de la matriz copiaría todos los cuatro elementos de la primera fila (o columna) y los dos primeros elementos de la segunda fila (o columna).For example, if an array has three rows (or columns) with four elements each, copying six elements from the beginning of the array would copy all four elements of the first row (or column) and the first two elements of the second row (or column). Para empezar a copiar en el segundo elemento de la fila de terceros (o columna), sourceIndex debe ser el límite superior de la primera fila (o columna) y la longitud de la segunda fila (o columna) más dos.To start copying from the second element of the third row (or column), sourceIndex must be the upper bound of the first row (or column) plus the length of the second row (or column) plus two.

Si sourceArray y destinationArray se superponen, este método se comporta como si los valores originales de sourceArray se conservaron en una ubicación temporal antes de destinationArray se sobrescribe.If sourceArray and destinationArray overlap, this method behaves as if the original values of sourceArray were preserved in a temporary location before destinationArray is overwritten.

[C++][C++]

Este método es equivalente a la función de C o C++ estándar memmove, no memcpy.This method is equivalent to the standard C/C++ function memmove, not memcpy.

Las matrices pueden ser matrices de tipo de referencia o matrices de tipo de valor.The arrays can be reference-type arrays or value-type arrays. Se realiza la conversión de tipo, según sea necesario.Type downcasting is performed, as required.

  • Al copiar desde una matriz de tipo de referencia a una matriz de tipo de valor, cada elemento se aplica la conversión unboxing y, a continuación, se copian.When copying from a reference-type array to a value-type array, each element is unboxed and then copied. Al copiar desde una matriz de tipo de valor a una matriz de tipo de referencia, cada elemento es aplicar la conversión boxing y, a continuación, se copian.When copying from a value-type array to a reference-type array, each element is boxed and then copied.

  • Cuando se copian de una matriz de tipo de valor o referencia a un Object matriz, un Object se crea para contener cada valor o referencia y, a continuación, se copian.When copying from a reference-type or value-type array to an Object array, an Object is created to hold each value or reference and then copied. Al copiar desde un Object matriz a una matriz de tipo de referencia o tipo de valor y la asignación no es posible, un InvalidCastException se produce.When copying from an Object array to a reference-type or value-type array and the assignment is not possible, an InvalidCastException is thrown.

  • Si sourceArray y destinationArray son ambas matrices de tipo de referencia o ambas matrices de tipo Object, se realiza una copia superficial.If sourceArray and destinationArray are both reference-type arrays or are both arrays of type Object, a shallow copy is performed. Una copia superficial de un Array es una nueva Array que contienen referencias a los mismos elementos que el original Array.A shallow copy of an Array is a new Array containing references to the same elements as the original Array. Los elementos no se copian a sí mismos o cualquier cosa que hace referencia a los elementos.The elements themselves or anything referenced by the elements are not copied. En cambio, una copia profunda de un Array copia los elementos y todo lo que hace referencia directa o indirectamente por los elementos.In contrast, a deep copy of an Array copies the elements and everything directly or indirectly referenced by the elements.

Un ArrayTypeMismatchException se produce si las matrices son tipos incompatibles.An ArrayTypeMismatchException is thrown if the arrays are of incompatible types. Compatibilidad de tipo se define como sigue:Type compatibility is defined as follows:

  • Un tipo es compatible con sí mismo.A type is compatible with itself.

  • Es compatible con un tipo de valor Object y con un tipo de interfaz implementado por ese tipo de valor.A value type is compatible with Object and with an interface type implemented by that value type. Se considera un tipo de valor conectado a una interfaz solo si implementa esa interfaz directamente.A value type is considered connected to an interface only if it implements that interface directly. Los tipos desconectados no son compatibles.Disconnected types are not compatible.

  • Dos tipos de valor (predefinido) intrínsecos son compatibles si la copia del tipo de origen al tipo de destino es una conversión de ampliación.Two intrinsic (predefined) value types are compatible if copying from the source type to the destination type is a widening conversion. Una conversión de ampliación nunca pierde información, mientras que una conversión de restricción puede perder información.A widening conversion never loses information, whereas a narrowing conversion can lose information. Por ejemplo, convertir a un entero de 32 bits con signo en un entero de 64 bits con signo es una conversión de ampliación y la conversión de un entero de 64 bits con signo en un entero de 32 bits con signo es una conversión de restricción.For example, converting a 32-bit signed integer to a 64-bit signed integer is a widening conversion, and converting a 64-bit signed integer to a 32-bit signed integer is a narrowing conversion. Para obtener más información sobre las conversiones, vea Convert.For more information about conversions, see Convert.

  • Un tipo no intrínseco valor (definido por el usuario) es compatible sólo con sí mismo.A nonintrinsic (user-defined) value type is compatible only with itself.

  • Las enumeraciones tienen una conversión implícita a Enum y a su tipo subyacente.Enumerations have an implicit conversion to Enum and to their underlying type.

Si todos los elementos de sourceArray requiere una conversión inferior (por ejemplo, desde una clase base para una clase derivada o desde una interfaz a un objeto) y uno o varios elementos no se puede convertir al tipo correspondiente en destinationArray, un InvalidCastException se produce.If every element in sourceArray requires a downcast (for example, from a base class to a derived class or from an interface to an object) and one or more elements cannot be cast to the corresponding type in destinationArray, an InvalidCastException is thrown.

Si este método produce una excepción durante la copia, el estado de destinationArray es indefinido.If this method throws an exception while copying, the state of destinationArray is undefined.

Este método es O (n) operación, donde n es length.This method is an O(n) operation, where n is length.

Consulte también:

Copy(Array, Int32, Array, Int32, Int32) Copy(Array, Int32, Array, Int32, Int32) Copy(Array, Int32, Array, Int32, Int32) 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.Copies a range of elements from an Array starting at the specified source index and pastes them to another Array starting at the specified destination index. La longitud y los índices se especifican como enteros de 32 bits.The length and the indexes are specified as 32-bit integers.

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

Array que contiene los datos que se van a copiar.The Array that contains the data to copy.

sourceIndex
Int32 Int32 Int32 Int32

Entero de 32 bits que representa el índice de la sourceArray en la que se empieza a copiar.A 32-bit integer that represents the index in the sourceArray at which copying begins.

destinationArray
Array Array Array Array

Array que recibe los datos.The Array that receives the data.

destinationIndex
Int32 Int32 Int32 Int32

Entero de 32 bits que representa el índice de la destinationArray en la que se empieza a almacenar.A 32-bit integer that represents the index in the destinationArray at which storing begins.

length
Int32 Int32 Int32 Int32

Entero de 32 bits que representa el número de elementos que se van a copiar.A 32-bit integer that represents the number of elements to copy.

Excepciones

El valor de sourceArray es null.sourceArray is null.

-o bien--or- El valor de destinationArray es null.destinationArray is null.

sourceArray y destinationArray tienen clasificaciones diferentes.sourceArray and destinationArray have different ranks.

sourceArray y destinationArray son de tipos incompatibles.sourceArray and destinationArray are of incompatible types.

Al menos un elemento de sourceArray no se puede convertir al tipo de destinationArray.At least one element in sourceArray cannot be cast to the type of destinationArray.

sourceIndex es menor que el límite inferior de la primera dimensión de sourceArray.sourceIndex is less than the lower bound of the first dimension of sourceArray.

-o bien--or- destinationIndex es menor que el límite inferior de la primera dimensión de destinationArray.destinationIndex is less than the lower bound of the first dimension of destinationArray.

-o bien--or- length es menor que cero.length is less than zero.

length es mayor que el número de elementos desde sourceIndex hasta el final de sourceArray.length is greater than the number of elements from sourceIndex to the end of sourceArray.

-o bien--or- length es mayor que el número de elementos desde destinationIndex hasta el final de destinationArray.length is greater than the number of elements from destinationIndex to the end of destinationArray.

Ejemplos

El ejemplo de código siguiente muestra cómo copiar desde una Array typu Object a otro Array de tipo entero.The following code example shows how to copy from one Array of type Object to another Array of type integer.

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
 */
using System;
public class SamplesArray  {

   public static void Main()  {

      // Creates and initializes a new Array of type Int32.
      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( "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 );
   }


   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.

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
*/
Imports System
Imports Microsoft.VisualBasic

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

Comentarios

El sourceArray y destinationArray parámetros deben tener el mismo número de dimensiones.The sourceArray and destinationArray parameters must have the same number of dimensions. Además, destinationArray debe ya han dimensionada y debe tener un número suficiente de elementos a partir de la destinationIndex posición para dar cabida a los datos copiados.In addition, destinationArray must already have been dimensioned and must have a sufficient number of elements starting from the destinationIndex position to accommodate the copied data.

Al copiar datos entre las matrices multidimensionales, la matriz se comporta como una matriz unidimensional larga, donde las filas (o columnas) se distribuyen conceptualmente-to-end.When copying between multidimensional arrays, the array behaves like a long one-dimensional array, where the rows (or columns) are conceptually laid end-to-end. Por ejemplo, si una matriz tiene tres filas (o columnas) con cuatro elementos cada uno, copian seis elementos desde el principio de la matriz copiaría todos los cuatro elementos de la primera fila (o columna) y los dos primeros elementos de la segunda fila (o columna).For example, if an array has three rows (or columns) with four elements each, copying six elements from the beginning of the array would copy all four elements of the first row (or column) and the first two elements of the second row (or column). Para empezar a copiar en el segundo elemento de la fila de terceros (o columna), sourceIndex debe ser el límite superior de la primera fila (o columna) y la longitud de la segunda fila (o columna) más dos.To start copying from the second element of the third row (or column), sourceIndex must be the upper bound of the first row (or column) plus the length of the second row (or column) plus two.

Si sourceArray y destinationArray se superponen, este método se comporta como si los valores originales de sourceArray se conservaron en una ubicación temporal antes de destinationArray se sobrescribe.If sourceArray and destinationArray overlap, this method behaves as if the original values of sourceArray were preserved in a temporary location before destinationArray is overwritten.

[C++][C++]

Este método es equivalente a la función de C o C++ estándar memmove, no memcpy.This method is equivalent to the standard C/C++ function memmove, not memcpy.

Las matrices pueden ser matrices de tipo de referencia o matrices de tipo de valor.The arrays can be reference-type arrays or value-type arrays. Se realiza la conversión de tipo, según sea necesario.Type downcasting is performed, as required.

  • Al copiar desde una matriz de tipo de referencia a una matriz de tipo de valor, cada elemento se aplica la conversión unboxing y, a continuación, se copian.When copying from a reference-type array to a value-type array, each element is unboxed and then copied. Al copiar desde una matriz de tipo de valor a una matriz de tipo de referencia, cada elemento es aplicar la conversión boxing y, a continuación, se copian.When copying from a value-type array to a reference-type array, each element is boxed and then copied.

  • Cuando se copian de una matriz de tipo de valor o referencia a un Object matriz, un Object se crea para contener cada valor o referencia y, a continuación, se copian.When copying from a reference-type or value-type array to an Object array, an Object is created to hold each value or reference and then copied. Al copiar desde un Object matriz a una matriz de tipo de referencia o tipo de valor y la asignación no es posible, un InvalidCastException se produce.When copying from an Object array to a reference-type or value-type array and the assignment is not possible, an InvalidCastException is thrown.

  • Si sourceArray y destinationArray son ambas matrices de tipo de referencia o ambas matrices de tipo Object, se realiza una copia superficial.If sourceArray and destinationArray are both reference-type arrays or are both arrays of type Object, a shallow copy is performed. Una copia superficial de un Array es una nueva Array que contienen referencias a los mismos elementos que el original Array.A shallow copy of an Array is a new Array containing references to the same elements as the original Array. Los elementos no se copian a sí mismos o cualquier cosa que hace referencia a los elementos.The elements themselves or anything referenced by the elements are not copied. En cambio, una copia profunda de un Array copia los elementos y todo lo que hace referencia directa o indirectamente por los elementos.In contrast, a deep copy of an Array copies the elements and everything directly or indirectly referenced by the elements.

Un ArrayTypeMismatchException se produce si las matrices son tipos incompatibles.An ArrayTypeMismatchException is thrown if the arrays are of incompatible types. Compatibilidad de tipo se define como sigue:Type compatibility is defined as follows:

  • Un tipo es compatible con sí mismo.A type is compatible with itself.

  • Es compatible con un tipo de valor Object y con un tipo de interfaz implementado por ese tipo de valor.A value type is compatible with Object and with an interface type implemented by that value type. Se considera un tipo de valor conectado a una interfaz solo si implementa esa interfaz directamente.A value type is considered connected to an interface only if it implements that interface directly. Los tipos desconectados no son compatibles.Disconnected types are not compatible.

  • Dos tipos de valor (predefinido) intrínsecos son compatibles si la copia del tipo de origen al tipo de destino es una conversión de ampliación.Two intrinsic (predefined) value types are compatible if copying from the source type to the destination type is a widening conversion. Una conversión de ampliación nunca pierde información, mientras que una conversión de restricción puede perder información.A widening conversion never loses information, whereas a narrowing conversion can lose information. Por ejemplo, convertir a un entero de 32 bits con signo en un entero de 64 bits con signo es una conversión de ampliación y la conversión de un entero de 64 bits con signo en un entero de 32 bits con signo es una conversión de restricción.For example, converting a 32-bit signed integer to a 64-bit signed integer is a widening conversion, and converting a 64-bit signed integer to a 32-bit signed integer is a narrowing conversion. Para obtener más información sobre las conversiones, vea Convert.For more information about conversions, see Convert.

  • Un tipo no intrínseco valor (definido por el usuario) es compatible sólo con sí mismo.A nonintrinsic (user-defined) value type is compatible only with itself.

  • Las enumeraciones tienen una conversión implícita a Enum y a su tipo subyacente.Enumerations have an implicit conversion to Enum and to their underlying type.

Si todos los elementos de sourceArray requiere una conversión inferior (por ejemplo, desde una clase base para una clase derivada o desde una interfaz a un objeto) y uno o varios elementos no se puede convertir al tipo correspondiente en destinationArray, un InvalidCastException se produce.If every element in sourceArray requires a downcast (for example, from a base class to a derived class or from an interface to an object) and one or more elements cannot be cast to the corresponding type in destinationArray, an InvalidCastException is thrown.

Si este método produce una excepción durante la copia, el estado de destinationArray es indefinido.If this method throws an exception while copying, the state of destinationArray is undefined.

Este método es O (n) operación, donde n es length.This method is an O(n) operation, where n is length.

Consulte también:

Copy(Array, Array, Int64) Copy(Array, Array, Int64) Copy(Array, Array, Int64) 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.Copies a range of elements from an Array starting at the first element and pastes them into another Array starting at the first element. La longitud se especifica como un entero de 64 bits.The length is specified as a 64-bit integer.

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

Array que contiene los datos que se van a copiar.The Array that contains the data to copy.

destinationArray
Array Array Array Array

Array que recibe los datos.The Array that receives the data.

length
Int64 Int64 Int64 Int64

Entero de 64 bits que representa el número de elementos que se van a copiar.A 64-bit integer that represents the number of elements to copy. El entero debe estar entre cero y MaxValue, ambos inclusive.The integer must be between zero and MaxValue, inclusive.

Excepciones

El valor de sourceArray es null.sourceArray is null.

-o bien--or- El valor de destinationArray es null.destinationArray is null.

sourceArray y destinationArray tienen clasificaciones diferentes.sourceArray and destinationArray have different ranks.

sourceArray y destinationArray son de tipos incompatibles.sourceArray and destinationArray are of incompatible types.

Al menos un elemento de sourceArray no se puede convertir al tipo de destinationArray.At least one element in sourceArray cannot be cast to the type of destinationArray.

length es mayor que el número de elementos de sourceArray.length is greater than the number of elements in sourceArray.

-o bien--or- length es mayor que el número de elementos de destinationArray.length is greater than the number of elements in destinationArray.

Comentarios

El sourceArray y destinationArray parámetros deben tener el mismo número de dimensiones.The sourceArray and destinationArray parameters must have the same number of dimensions. Además, destinationArray debe ya han dimensionada y debe tener un número suficiente de elementos para dar cabida a los datos copiados.In addition, destinationArray must already have been dimensioned and must have a sufficient number of elements to accommodate the copied data.

Al copiar datos entre las matrices multidimensionales, la matriz se comporta como una matriz unidimensional larga, donde las filas (o columnas) se distribuyen conceptualmente de extremo a extremo.When copying between multidimensional arrays, the array behaves like a long one-dimensional array, where the rows (or columns) are conceptually laid end to end. Por ejemplo, si una matriz tiene tres filas (o columnas) con cuatro elementos cada uno, copian seis elementos desde el principio de la matriz copiaría todos los cuatro elementos de la primera fila (o columna) y los dos primeros elementos de la segunda fila (o columna).For example, if an array has three rows (or columns) with four elements each, copying six elements from the beginning of the array would copy all four elements of the first row (or column) and the first two elements of the second row (or column).

Si sourceArray y destinationArray se superponen, este método se comporta como si los valores originales de sourceArray se conservaron en una ubicación temporal antes de destinationArray se sobrescribe.If sourceArray and destinationArray overlap, this method behaves as if the original values of sourceArray were preserved in a temporary location before destinationArray is overwritten.

[C++][C++]

Este método es equivalente a la función de C o C++ estándar memmove, no memcpy.This method is equivalent to the standard C/C++ function memmove, not memcpy.

Las matrices pueden ser matrices de tipo de referencia o matrices de tipo de valor.The arrays can be reference-type arrays or value-type arrays. Se realiza la conversión de tipo, según sea necesario.Type downcasting is performed, as required.

  • Al copiar desde una matriz de tipo de referencia a una matriz de tipo de valor, cada elemento se aplica la conversión unboxing y, a continuación, se copian.When copying from a reference-type array to a value-type array, each element is unboxed and then copied. Al copiar desde una matriz de tipo de valor a una matriz de tipo de referencia, cada elemento es aplicar la conversión boxing y, a continuación, se copian.When copying from a value-type array to a reference-type array, each element is boxed and then copied.

  • Cuando se copian de una matriz de tipo de valor o referencia a un Object matriz, un Object se crea para contener cada valor o referencia y, a continuación, se copian.When copying from a reference-type or value-type array to an Object array, an Object is created to hold each value or reference and then copied. Al copiar desde un Object matriz a una matriz de tipo de referencia o tipo de valor y la asignación no es posible, un InvalidCastException se produce.When copying from an Object array to a reference-type or value-type array and the assignment is not possible, an InvalidCastException is thrown.

  • Si sourceArray y destinationArray son ambas matrices de tipo de referencia o ambas matrices de tipo Object, se realiza una copia superficial.If sourceArray and destinationArray are both reference-type arrays or are both arrays of type Object, a shallow copy is performed. Una copia superficial de un Array es una nueva Array que contienen referencias a los mismos elementos que el original Array.A shallow copy of an Array is a new Array containing references to the same elements as the original Array. Los elementos no se copian a sí mismos o cualquier cosa que hace referencia a los elementos.The elements themselves or anything referenced by the elements are not copied. En cambio, una copia profunda de un Array copia los elementos y todo lo que hace referencia directa o indirectamente por los elementos.In contrast, a deep copy of an Array copies the elements and everything directly or indirectly referenced by the elements.

Un ArrayTypeMismatchException se produce si las matrices son tipos incompatibles.An ArrayTypeMismatchException is thrown if the arrays are of incompatible types. Compatibilidad de tipo se define como sigue:Type compatibility is defined as follows:

  • Un tipo es compatible con sí mismo.A type is compatible with itself.

  • Es compatible con un tipo de valor Object y con un tipo de interfaz implementado por ese tipo de valor.A value type is compatible with Object and with an interface type implemented by that value type. Se considera un tipo de valor conectado a una interfaz solo si implementa esa interfaz directamente.A value type is considered connected to an interface only if it implements that interface directly. Los tipos desconectados no son compatibles.Disconnected types are not compatible.

  • Dos tipos de valor (predefinido) intrínsecos son compatibles si la copia del tipo de origen al tipo de destino es una conversión de ampliación.Two intrinsic (predefined) value types are compatible if copying from the source type to the destination type is a widening conversion. Una conversión de ampliación nunca pierde información, mientras que una conversión de restricción puede perder información.A widening conversion never loses information, whereas a narrowing conversion can lose information. Por ejemplo, convertir a un entero de 32 bits con signo en un entero de 64 bits con signo es una conversión de ampliación y la conversión de un entero de 64 bits con signo en un entero de 32 bits con signo es una conversión de restricción.For example, converting a 32-bit signed integer to a 64-bit signed integer is a widening conversion, and converting a 64-bit signed integer to a 32-bit signed integer is a narrowing conversion. Para obtener más información sobre las conversiones, vea Convert.For more information about conversions, see Convert.

  • Un tipo no intrínseco valor (definido por el usuario) es compatible sólo con sí mismo.A nonintrinsic (user-defined) value type is compatible only with itself.

  • Las enumeraciones tienen una conversión implícita a Enum y a su tipo subyacente.Enumerations have an implicit conversion to Enum and to their underlying type.

Si todos los elementos de sourceArray requiere una conversión inferior (por ejemplo, desde una clase base para una clase derivada o desde una interfaz a un objeto) y uno o varios elementos no se puede convertir al tipo correspondiente en destinationArray, un InvalidCastException se produce.If every element in sourceArray requires a downcast (for example, from a base class to a derived class or from an interface to an object) and one or more elements cannot be cast to the corresponding type in destinationArray, an InvalidCastException is thrown.

Si este método produce una excepción durante la copia, el estado de destinationArray es indefinido.If this method throws an exception while copying, the state of destinationArray is undefined.

Este método es O (n) operación, donde n es length.This method is an O(n) operation, where n is length.

Consulte también:

Copy(Array, Array, Int32) Copy(Array, Array, Int32) Copy(Array, Array, Int32) 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.Copies a range of elements from an Array starting at the first element and pastes them into another Array starting at the first element. La longitud se especifica como un entero de 32 bits.The length is specified as a 32-bit integer.

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

Array que contiene los datos que se van a copiar.The Array that contains the data to copy.

destinationArray
Array Array Array Array

Array que recibe los datos.The Array that receives the data.

length
Int32 Int32 Int32 Int32

Entero de 32 bits que representa el número de elementos que se van a copiar.A 32-bit integer that represents the number of elements to copy.

Excepciones

El valor de sourceArray es null.sourceArray is null.

-o bien--or- El valor de destinationArray es null.destinationArray is null.

sourceArray y destinationArray tienen clasificaciones diferentes.sourceArray and destinationArray have different ranks.

sourceArray y destinationArray son de tipos incompatibles.sourceArray and destinationArray are of incompatible types.

Al menos un elemento de la sourceArray no se puede convertir al tipo de destinationArray.At least one element in sourceArray cannot be cast to the type of destinationArray.

length es mayor que el número de elementos de sourceArray.length is greater than the number of elements in sourceArray.

-o bien--or- length es mayor que el número de elementos de destinationArray.length is greater than the number of elements in destinationArray.

Comentarios

El sourceArray y destinationArray parámetros deben tener el mismo número de dimensiones.The sourceArray and destinationArray parameters must have the same number of dimensions. Además, destinationArray debe ya han dimensionada y debe tener un número suficiente de elementos para dar cabida a los datos copiados.In addition, destinationArray must already have been dimensioned and must have a sufficient number of elements to accommodate the copied data.

Al copiar datos entre las matrices multidimensionales, la matriz se comporta como una matriz unidimensional larga, donde las filas (o columnas) se distribuyen conceptualmente de extremo a extremo.When copying between multidimensional arrays, the array behaves like a long one-dimensional array, where the rows (or columns) are conceptually laid end to end. Por ejemplo, si una matriz tiene tres filas (o columnas) con cuatro elementos cada uno, copian seis elementos desde el principio de la matriz copiaría todos los cuatro elementos de la primera fila (o columna) y los dos primeros elementos de la segunda fila (o columna).For example, if an array has three rows (or columns) with four elements each, copying six elements from the beginning of the array would copy all four elements of the first row (or column) and the first two elements of the second row (or column).

Si sourceArray y destinationArray se superponen, este método se comporta como si los valores originales de sourceArray se conservaron en una ubicación temporal antes de destinationArray se sobrescribe.If sourceArray and destinationArray overlap, this method behaves as if the original values of sourceArray were preserved in a temporary location before destinationArray is overwritten.

[C++][C++]

Este método es equivalente a la función de C o C++ estándar memmove, no memcpy.This method is equivalent to the standard C/C++ function memmove, not memcpy.

Las matrices pueden ser matrices de tipo de referencia o matrices de tipo de valor.The arrays can be reference-type arrays or value-type arrays. Se realiza la conversión de tipo, según sea necesario.Type downcasting is performed, as required.

  • Al copiar desde una matriz de tipo de referencia a una matriz de tipo de valor, cada elemento se aplica la conversión unboxing y, a continuación, se copian.When copying from a reference-type array to a value-type array, each element is unboxed and then copied. Al copiar desde una matriz de tipo de valor a una matriz de tipo de referencia, cada elemento es aplicar la conversión boxing y, a continuación, se copian.When copying from a value-type array to a reference-type array, each element is boxed and then copied.

  • Cuando se copian de una matriz de tipo de valor o referencia a un Object matriz, un Object se crea para contener cada valor o referencia y, a continuación, se copian.When copying from a reference-type or value-type array to an Object array, an Object is created to hold each value or reference and then copied. Al copiar desde un Object matriz a una matriz de tipo de referencia o tipo de valor y la asignación no es posible, un InvalidCastException se produce.When copying from an Object array to a reference-type or value-type array and the assignment is not possible, an InvalidCastException is thrown.

  • Si sourceArray y destinationArray son ambas matrices de tipo de referencia o ambas matrices de tipo Object, se realiza una copia superficial.If sourceArray and destinationArray are both reference-type arrays or are both arrays of type Object, a shallow copy is performed. Una copia superficial de un Array es una nueva Array que contienen referencias a los mismos elementos que el original Array.A shallow copy of an Array is a new Array containing references to the same elements as the original Array. Los elementos no se copian a sí mismos o cualquier cosa que hace referencia a los elementos.The elements themselves or anything referenced by the elements are not copied. En cambio, una copia profunda de un Array copia los elementos y todo lo que hace referencia directa o indirectamente por los elementos.In contrast, a deep copy of an Array copies the elements and everything directly or indirectly referenced by the elements.

Un ArrayTypeMismatchException se produce si las matrices son tipos incompatibles.An ArrayTypeMismatchException is thrown if the arrays are of incompatible types. Compatibilidad de tipo se define como sigue:Type compatibility is defined as follows:

  • Un tipo es compatible con sí mismo.A type is compatible with itself.

  • Es compatible con un tipo de valor Object y con un tipo de interfaz implementado por ese tipo de valor.A value type is compatible with Object and with an interface type implemented by that value type. Se considera un tipo de valor conectado a una interfaz solo si implementa esa interfaz directamente.A value type is considered connected to an interface only if it implements that interface directly. Los tipos desconectados no son compatibles.Disconnected types are not compatible.

  • Dos tipos de valor (predefinido) intrínsecos son compatibles si la copia del tipo de origen al tipo de destino es una conversión de ampliación.Two intrinsic (predefined) value types are compatible if copying from the source type to the destination type is a widening conversion. Una conversión de ampliación nunca pierde información, mientras que una conversión de restricción puede perder información.A widening conversion never loses information, whereas a narrowing conversion can lose information. Por ejemplo, convertir a un entero de 32 bits con signo en un entero de 64 bits con signo es una conversión de ampliación y la conversión de un entero de 64 bits con signo en un entero de 32 bits con signo es una conversión de restricción.For example, converting a 32-bit signed integer to a 64-bit signed integer is a widening conversion, and converting a 64-bit signed integer to a 32-bit signed integer is a narrowing conversion. Para obtener más información sobre las conversiones, vea Convert.For more information about conversions, see Convert.

  • Un tipo no intrínseco valor (definido por el usuario) es compatible sólo con sí mismo.A nonintrinsic (user-defined) value type is compatible only with itself.

  • Las enumeraciones tienen una conversión implícita a Enum y a su tipo subyacente.Enumerations have an implicit conversion to Enum and to their underlying type.

Si todos los elementos de sourceArray requiere una conversión inferior (por ejemplo, desde una clase base para una clase derivada o desde una interfaz a un objeto) y uno o varios elementos no se puede convertir al tipo correspondiente en destinationArray, un InvalidCastException se produce.If every element in sourceArray requires a downcast (for example, from a base class to a derived class or from an interface to an object) and one or more elements cannot be cast to the corresponding type in destinationArray, an InvalidCastException is thrown.

Si este método produce una excepción durante la copia, el estado de destinationArray es indefinido.If this method throws an exception while copying, the state of destinationArray is undefined.

Este método es O (n) operación, donde n es length.This method is an O(n) operation, where n is length.

Consulte también:

Se aplica a