CopyTo Método (Array, Int64)
Collapse the table of content
Expand the table of content
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

Array.CopyTo (Método) (Array, Int64)

 

Copia todos los elementos de la matriz unidimensional actual en la matriz unidimensional especificada, empezando en el índice especificado de la matriz de destino.El índice se especifica como un entero de 64 bits.

Espacio de nombres:   System
Ensamblado:  mscorlib (en mscorlib.dll)

[ComVisibleAttribute(false)]
public void CopyTo(
	Array array,
	long index
)

Parámetros

array

Matriz unidimensional que constituye el destino de los elementos copiados desde la matriz actual.

index

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

Exception Condition
ArgumentNullException

El valor de array es null.

ArgumentOutOfRangeException

El valor de index se encuentra fuera del intervalo de índices válidos para array.

ArgumentException

array es multidimensional.

o bien

El número de elementos de la matriz de origen es mayor que el número de elementos disponibles desde el index hasta el final de la array de destino.

ArrayTypeMismatchException

El tipo de la interfaz Array de origen no se puede convertir automáticamente al tipo de la matriz array de destino.

RankException

La matriz Array de origen es multidimensional.

InvalidCastException

Al menos un elemento del objeto Array de origen no puede convertirse en el tipo del parámetro array de destino.

Este método copia todos los elementos de la instancia actual de la matriz a la array matriz de destino, empezando por el índice index.El array la matriz de destino debe ya han dimensionada y debe tener un número suficiente de elementos para dar cabida a los elementos copiados.De lo contrario, el método produce una excepción.

Este método admite la System.Collections.ICollection interfaz.Si se implementa System.Collections.ICollection es necesario no explícitamente, utilice Copy para evitar un direccionamiento indirecto adicional.

Si este método produce una excepción durante la copia, el estado de array es indefinido.

Este método es una E/s (n) operación, donde n es Length.Realiza una copia superficial sólo.

En el ejemplo de código siguiente se muestra cómo copiar un Array a otro Array.

using System;
public class SamplesArray  {

   public static void Main()  {

      // Creates and initializes two new Arrays.
      Array mySourceArray=Array.CreateInstance( typeof(String), 6 );
      mySourceArray.SetValue( "three", 0 );
      mySourceArray.SetValue( "napping", 1 );
      mySourceArray.SetValue( "cats", 2 );
      mySourceArray.SetValue( "in", 3 );
      mySourceArray.SetValue( "the", 4 );
      mySourceArray.SetValue( "barn", 5 );
      Array myTargetArray=Array.CreateInstance( typeof(String), 15 );
      myTargetArray.SetValue( "The", 0 );
      myTargetArray.SetValue( "quick", 1 );
      myTargetArray.SetValue( "brown", 2 );
      myTargetArray.SetValue( "fox", 3 );
      myTargetArray.SetValue( "jumps", 4 );
      myTargetArray.SetValue( "over", 5 );
      myTargetArray.SetValue( "the", 6 );
      myTargetArray.SetValue( "lazy", 7 );
      myTargetArray.SetValue( "dog", 8 );

      // Displays the values of the Array.
      Console.WriteLine( "The target Array contains the following (before and after copying):" );
      PrintValues( myTargetArray, ' ' );

      // Copies the source Array to the target Array, starting at index 6.
      mySourceArray.CopyTo( myTargetArray, 6 );

      // Displays the values of the Array.
      PrintValues( myTargetArray, ' ' );
   }


   public static void PrintValues( Array myArr, char mySeparator )  {
      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( "{0}{1}", mySeparator, myEnumerator.Current );
      }
      Console.WriteLine();
   }
}
/*
This code produces the following output.

 The target Array contains the following (before and after copying):
 The quick brown fox jumps over the lazy dog      
 The quick brown fox jumps over three napping cats in the barn
*/

En el ejemplo de código siguiente se muestra cómo copiar un Array a otro Array con un límite inferior distinto de cero.Tenga en cuenta que el código fuente completo Array copiado, incluidos los elementos vacíos que sobrescriben los elementos existentes en el destino Array.

public class SamplesArray2{

   public static void Main()  {
      // Creates and initializes the source Array.
      Array myArrayZero=Array.CreateInstance( typeof(String), 3 );
      myArrayZero.SetValue( "zero", 0 );
      myArrayZero.SetValue( "one", 1 );

      // Displays the source Array.
      Console.WriteLine( "The array with lower bound=0 contains:" );
      PrintIndexAndValues( myArrayZero );

      // Creates and initializes the target Array.
      int[] myArrLen = { 4 };
      int[] myArrLow = { 2 };
      Array myArrayTwo=Array.CreateInstance( typeof(String), myArrLen, myArrLow );
      myArrayTwo.SetValue( "two", 2 );
      myArrayTwo.SetValue( "three", 3 );
      myArrayTwo.SetValue( "four", 4 );
      myArrayTwo.SetValue( "five", 5 );

      // Displays the target Array.
      Console.WriteLine( "The array with lower bound=2 contains:" );
      PrintIndexAndValues( myArrayTwo );

      // Copies from the array with lower bound=0 to the array with lower bound=2.
      myArrayZero.CopyTo( myArrayTwo, 3 );

      // Displays the modified target Array.
      Console.WriteLine( "\nAfter copying to the target array from index 3:" );
      PrintIndexAndValues( myArrayTwo );
   }


   public static void PrintIndexAndValues( Array myArray )  {
      for ( int i = myArray.GetLowerBound(0); i <= myArray.GetUpperBound(0); i++ )
         Console.WriteLine( "\t[{0}]:\t{1}", i, myArray.GetValue( i ) );
   }
}
/* 
This code produces the following output.

The array with lower bound=0 contains:
    [0]:    zero
    [1]:    one
    [2]:    
The array with lower bound=2 contains:
    [2]:    two
    [3]:    three
    [4]:    four
    [5]:    five

After copying to the target array from index 3:
    [2]:    two
    [3]:    zero
    [4]:    one
    [5]:
*/

.NET Framework
Disponible desde 1.1
Volver al principio
Mostrar:
© 2016 Microsoft