Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Metodo Array.CopyTo (Array, Int64)

 

Data di pubblicazione: ottobre 2016

Copia tutti gli elementi dell'attuale matrice unidimensionale nella matrice unidimensionale specificata a partire dall'indice della matrice di destinazione indicato. L'indice viene specificato come intero a 64 bit.

Spazio dei nomi:   System
Assembly:  mscorlib (in mscorlib.dll)

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

Parametri

array
Type: System.Array

Matrice unidimensionale che costituisce la destinazione degli elementi copiati dalla matrice corrente.

index
Type: System.Int64

Intero a 64 bit che rappresenta l'indice in array da cui viene avviata la copia.

Exception Condition
ArgumentNullException

array è null.

ArgumentOutOfRangeException

index non è compreso nell'intervallo di indici validi per array.

ArgumentException

array è multidimensionale.

-oppure-

Il numero di elementi nella matrice di origine è maggiore del numero disponibile di elementi da index alla fine dell'oggetto array di destinazione.

ArrayTypeMismatchException

Non è possibile eseguire il cast automatico del tipo dell'oggetto Array di origine al tipo dell'oggetto array di destinazione.

RankException

L'origine Array è multidimensionale.

InvalidCastException

Non è possibile eseguire il cast di almeno un elemento nell'oggetto Array di origine al tipo dell'oggetto array di destinazione.

Questo metodo copia tutti gli elementi dell'istanza corrente di matrice per la array matrice di destinazione, a partire dall'indice index. Il array matrice di destinazione deve già dimensionata e deve avere un numero sufficiente di elementi per contenere gli elementi copiati. In caso contrario, il metodo genererà un'eccezione.

Questo metodo supporta il System.Collections.ICollection interfaccia. Se l'implementazione System.Collections.ICollection è necessario non in modo esplicito, utilizzare Copy per evitare un riferimento indiretto aggiuntivo.

Se questo metodo genera un'eccezione durante la copia, lo stato di array non è definito.

Questo metodo è un'operazione O (n) operazione, in cui n è Length. Consente di eseguire solo una copia superficiale.

Esempio di codice seguente viene illustrato come copiare un Array a un altro 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
*/

Esempio di codice seguente viene illustrato come copiare un Array a un altro Array con limite inferiore diverso da zero. Si noti che l'intera origine Array viene copiato, inclusi gli elementi vuoti che sovrascrivono gli elementi esistenti nella destinazione 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
Disponibile da 1.1
Torna all'inizio
Mostra: