Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Método Array.CopyTo (Array, Int32)

 

Publicado: octubre de 2016

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 32 bits.

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

public void CopyTo(
	Array array,
	int index
)

Parámetros

array
Type: System.Array

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

index
Type: System.Int32

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

Exception Condition
ArgumentNullException

El valor de array es null.

ArgumentOutOfRangeException

index es menor que el límite inferior de array.

ArgumentException

array es multidimensional.

-o-

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

ArrayTypeMismatchException

El tipo de la Array de origen no puede convertirse automáticamente al tipo de la array de destino.

RankException

La matriz de origen es multidimensional.

InvalidCastException

Al menos un elemento de la Array de origen no se puede convertir al tipo de 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 matriz de destino debe ya ha dimensionadas 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 es compatible con la System.Collections.ICollection interfaz. Si se implementa System.Collections.ICollection es necesario no explícitamente, usar Copy para evitar un direccionamiento indirecto adicional.

Si este método produce una excepción durante la copia, el estado de array no está definido.

Este método es una O (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 Array se copia, 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]:
*/

Plataforma universal de Windows
Disponible desde 8
.NET Framework
Disponible desde 1.1
Biblioteca de clases portable
Se admite en: plataformas portátiles de .NET
Silverlight
Disponible desde 2.0
Windows Phone Silverlight
Disponible desde 7.0
Windows Phone
Disponible desde 8.1
Volver al principio
Mostrar: