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

Definizione

Copia un intervallo di elementi di un oggetto Array in un altro oggetto Array ed esegue il cast e il boxing del tipo secondo le necessità.Copies a range of elements in one Array to another Array and performs type casting and boxing as required.

Overload

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 intervallo di elementi da un oggetto Array a partire dall'indice di origine specificato e lo incolla in un altro oggetto Array a partire dall'indice di destinazione specificato.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 lunghezza e gli indici vengono specificati come interi a 64 bit.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 intervallo di elementi da un oggetto Array a partire dall'indice di origine specificato e lo incolla in un altro oggetto Array a partire dall'indice di destinazione specificato.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 lunghezza e gli indici vengono specificati come interi a 32 bit.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 intervallo di elementi da un oggetto Array a partire dal primo elemento e lo incolla in un altro oggetto Array a partire dal primo 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 lunghezza viene specificata come intero a 64 bit.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 intervallo di elementi da un oggetto Array a partire dal primo elemento e lo incolla in un altro oggetto Array a partire dal primo 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 lunghezza viene specificata come intero a 32 bit.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 intervallo di elementi da un oggetto Array a partire dall'indice di origine specificato e lo incolla in un altro oggetto Array a partire dall'indice di destinazione specificato.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 lunghezza e gli indici vengono specificati come interi a 64 bit.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)

Parametri

sourceArray
Array Array Array Array

Oggetto Array che contiene i dati da copiare.The Array that contains the data to copy.

sourceIndex
Int64 Int64 Int64 Int64

Intero a 64 bit che rappresenta l'indice in sourceArray da cui viene avviata la copia.A 64-bit integer that represents the index in the sourceArray at which copying begins.

destinationArray
Array Array Array Array

Oggetto Array che riceve i dati.The Array that receives the data.

destinationIndex
Int64 Int64 Int64 Int64

Intero a 64 bit che rappresenta l'indice in destinationArray da cui viene avviata l'archiviazione.A 64-bit integer that represents the index in the destinationArray at which storing begins.

length
Int64 Int64 Int64 Int64

Intero a 64 bit che rappresenta il numero di elementi da copiare.A 64-bit integer that represents the number of elements to copy. L'intero deve essere compreso tra zero e MaxValue, inclusi.The integer must be between zero and MaxValue, inclusive.

Eccezioni

sourceArray è null.sourceArray is null.

-oppure--or- destinationArray è null.destinationArray is null.

sourceArray e destinationArray hanno classificazioni diverse.sourceArray and destinationArray have different ranks.

I tipi di sourceArray e destinationArray sono incompatibili.sourceArray and destinationArray are of incompatible types.

Non è possibile eseguire il cast di almeno un elemento in sourceArray al tipo di destinationArray.At least one element in sourceArray cannot be cast to the type of destinationArray.

sourceIndex non è compreso nell'intervallo di indici validi per sourceArray.sourceIndex is outside the range of valid indexes for the sourceArray.

-oppure--or- destinationIndex non è compreso nell'intervallo di indici validi per destinationArray.destinationIndex is outside the range of valid indexes for the destinationArray.

-oppure--or- length è minore di 0 o maggiore di MaxValue.length is less than 0 or greater than MaxValue.

length è maggiore del numero di elementi compresi tra sourceIndex e la fine di sourceArray.length is greater than the number of elements from sourceIndex to the end of sourceArray.

-oppure--or- length è maggiore del numero di elementi compresi tra destinationIndex e la fine di destinationArray.length is greater than the number of elements from destinationIndex to the end of destinationArray.

Esempi

Nell'esempio di codice seguente viene illustrato come copiare da Array un tipo Object a un Array altro di tipo Integer.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

Commenti

I sourceArray parametri destinationArray e devono avere lo stesso numero di dimensioni.The sourceArray and destinationArray parameters must have the same number of dimensions. Inoltre, destinationArray deve essere già stato dimensionato e deve avere un numero sufficiente di elementi a partire destinationIndex dalla posizione per contenere i dati copiati.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.

Quando si esegue la copia tra matrici multidimensionali, la matrice si comporta come una matrice unidimensionale lunga, in cui le righe (o colonne) sono concettualmente definite end-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. Se, ad esempio, una matrice include tre righe (o colonne) con quattro elementi ciascuno, la copia di sei elementi dall'inizio della matrice comporterebbe la copia di tutti e quattro gli elementi della prima riga (o colonna) e dei primi due elementi della seconda riga o colonna.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). Per avviare la copia dal secondo elemento della terza riga (o colonna), sourceIndex deve essere il limite superiore della prima riga (o colonna) più la lunghezza della seconda riga (o colonna) più due.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.

Se sourceArray sourceArray destinationArray e destinationArray si sovrappongono, questo metodo si comporta come se i valori originali di fossero conservati in una posizione temporanea prima di essere sovrascritti.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++]

Questo metodo è equivalente alla funzioneC++ memmoveC/standard, non. memcpyThis method is equivalent to the standard C/C++ function memmove, not memcpy.

Le matrici possono essere matrici di tipi di riferimento o matrici di tipi di valore.The arrays can be reference-type arrays or value-type arrays. Il tipo downcast viene eseguito, come richiesto.Type downcasting is performed, as required.

  • Quando si esegue la copia da una matrice di tipo riferimento a una matrice di tipo valore, ogni elemento viene sottoposto a Boxing e quindi copiato.When copying from a reference-type array to a value-type array, each element is unboxed and then copied. Quando si esegue la copia da una matrice di tipo valore a una matrice di tipo riferimento, ogni elemento viene sottoposto a Boxing e quindi copiato.When copying from a value-type array to a reference-type array, each element is boxed and then copied.

  • Quando si esegue la copia da una matrice di tipo riferimento o valore a Object una matrice, Object viene creato un oggetto per conservare ogni valore o riferimento e quindi copiarlo.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. Quando si esegue la Object copia da una matrice a una matrice di tipo riferimento o valore e l'assegnazione non è possibile, InvalidCastException viene generata un'eccezione.When copying from an Object array to a reference-type or value-type array and the assignment is not possible, an InvalidCastException is thrown.

  • Se sourceArray Objecte destinationArray sono entrambe matrici di tipo riferimento o sono entrambe matrici di tipo, viene eseguita una copia superficiale.If sourceArray and destinationArray are both reference-type arrays or are both arrays of type Object, a shallow copy is performed. Una copia superficiale di un Array oggetto è un Array nuovo oggetto che contiene i riferimenti agli stessi elementi Arraydell'oggetto originale.A shallow copy of an Array is a new Array containing references to the same elements as the original Array. Gli elementi stessi o qualsiasi elemento a cui fanno riferimento gli elementi non vengono copiati.The elements themselves or anything referenced by the elements are not copied. Al contrario, una copia completa di un Array oggetto copia gli elementi e tutti gli elementi a cui fanno riferimento direttamente o indirettamente.In contrast, a deep copy of an Array copies the elements and everything directly or indirectly referenced by the elements.

Se ArrayTypeMismatchException le matrici sono di tipi incompatibili, viene generata un'eccezione.An ArrayTypeMismatchException is thrown if the arrays are of incompatible types. La compatibilità tra tipi viene definita nel modo seguente:Type compatibility is defined as follows:

  • Un tipo è compatibile con se stesso.A type is compatible with itself.

  • Un tipo di valore è compatibile Object con e con un tipo di interfaccia implementato da tale tipo di valore.A value type is compatible with Object and with an interface type implemented by that value type. Un tipo di valore viene considerato connesso a un'interfaccia solo se implementa direttamente tale interfaccia.A value type is considered connected to an interface only if it implements that interface directly. I tipi disconnessi non sono compatibili.Disconnected types are not compatible.

  • Due tipi di valore intrinseci (predefiniti) sono compatibili se la copia dal tipo di origine al tipo di destinazione è una conversione verso un tipo di dati più ampio.Two intrinsic (predefined) value types are compatible if copying from the source type to the destination type is a widening conversion. Una conversione verso un tipo di dati più ampio non perde mai informazioni, mentre una conversione verso un tipo di dati più piccolo può perdereA widening conversion never loses information, whereas a narrowing conversion can lose information. Ad esempio, la conversione di un intero con segno a 32 bit in un intero con segno a 64 bit è una conversione verso un tipo di caratteri più ampio e la conversione di un intero con segno a 64 bit in un intero con segno a 32 bit è una conversione verso un tipo di caratteri più piccoloFor 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. Per ulteriori informazioni sulle conversioni, vedere Convert.For more information about conversions, see Convert.

  • Un tipo di valore non intrinseco (definito dall'utente) è compatibile solo con se stesso.A nonintrinsic (user-defined) value type is compatible only with itself.

  • Le enumerazioni hanno una conversione implicita in Enum e nel relativo tipo sottostante.Enumerations have an implicit conversion to Enum and to their underlying type.

Se ogni elemento in sourceArray richiede un oggetto abbassato (ad esempio, da una classe base a una classe derivata o da un'interfaccia a un oggetto) e non è possibile eseguire il cast di uno o destinationArraypiù elementi InvalidCastException al tipo corrispondente in, viene generata un'eccezione.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.

Se questo metodo genera un'eccezione durante la copia, lo stato destinationArray di non è definito.If this method throws an exception while copying, the state of destinationArray is undefined.

Questo metodo è un'operazione On(), dove n è length.This method is an O(n) operation, where n is length.

Vedi anche

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 intervallo di elementi da un oggetto Array a partire dall'indice di origine specificato e lo incolla in un altro oggetto Array a partire dall'indice di destinazione specificato.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 lunghezza e gli indici vengono specificati come interi a 32 bit.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)

Parametri

sourceArray
Array Array Array Array

Oggetto Array che contiene i dati da copiare.The Array that contains the data to copy.

sourceIndex
Int32 Int32 Int32 Int32

Intero a 32 bit che rappresenta l'indice in sourceArray da cui viene avviata la copia.A 32-bit integer that represents the index in the sourceArray at which copying begins.

destinationArray
Array Array Array Array

Oggetto Array che riceve i dati.The Array that receives the data.

destinationIndex
Int32 Int32 Int32 Int32

Intero a 32 bit che rappresenta l'indice in destinationArray da cui viene avviata l'archiviazione.A 32-bit integer that represents the index in the destinationArray at which storing begins.

length
Int32 Int32 Int32 Int32

Intero a 32 bit che rappresenta il numero degli elementi da copiare.A 32-bit integer that represents the number of elements to copy.

Eccezioni

sourceArray è null.sourceArray is null.

In alternativa-or- destinationArray è null.destinationArray is null.

sourceArray e destinationArray hanno classificazioni diverse.sourceArray and destinationArray have different ranks.

I tipi di sourceArray e destinationArray sono incompatibili.sourceArray and destinationArray are of incompatible types.

Non è possibile eseguire il cast di almeno un elemento in sourceArray al tipo di destinationArray.At least one element in sourceArray cannot be cast to the type of destinationArray.

sourceIndex è minore del limite inferiore della prima dimensione di sourceArray.sourceIndex is less than the lower bound of the first dimension of sourceArray.

In alternativa-or- destinationIndex è minore del limite inferiore della prima dimensione di destinationArray.destinationIndex is less than the lower bound of the first dimension of destinationArray.

-oppure--or- length è minore di zero.length is less than zero.

length è maggiore del numero di elementi compresi tra sourceIndex e la fine di sourceArray.length is greater than the number of elements from sourceIndex to the end of sourceArray.

In alternativa-or- length è maggiore del numero di elementi compresi tra destinationIndex e la fine di destinationArray.length is greater than the number of elements from destinationIndex to the end of destinationArray.

Esempi

Nell'esempio di codice seguente viene illustrato come copiare da Array un tipo Object a un Array altro di tipo Integer.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

Commenti

I sourceArray parametri destinationArray e devono avere lo stesso numero di dimensioni.The sourceArray and destinationArray parameters must have the same number of dimensions. Inoltre, destinationArray deve essere già stato dimensionato e deve avere un numero sufficiente di elementi a partire destinationIndex dalla posizione per contenere i dati copiati.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.

Quando si esegue la copia tra matrici multidimensionali, la matrice si comporta come una matrice unidimensionale lunga, in cui le righe (o colonne) sono concettualmente definite end-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. Se, ad esempio, una matrice include tre righe (o colonne) con quattro elementi ciascuno, la copia di sei elementi dall'inizio della matrice comporterebbe la copia di tutti e quattro gli elementi della prima riga (o colonna) e dei primi due elementi della seconda riga o colonna.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). Per avviare la copia dal secondo elemento della terza riga (o colonna), sourceIndex deve essere il limite superiore della prima riga (o colonna) più la lunghezza della seconda riga (o colonna) più due.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.

Se sourceArray sourceArray destinationArray e destinationArray si sovrappongono, questo metodo si comporta come se i valori originali di fossero conservati in una posizione temporanea prima di essere sovrascritti.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++]

Questo metodo è equivalente alla funzioneC++ memmoveC/standard, non. memcpyThis method is equivalent to the standard C/C++ function memmove, not memcpy.

Le matrici possono essere matrici di tipi di riferimento o matrici di tipi di valore.The arrays can be reference-type arrays or value-type arrays. Il tipo downcast viene eseguito, come richiesto.Type downcasting is performed, as required.

  • Quando si esegue la copia da una matrice di tipo riferimento a una matrice di tipo valore, ogni elemento viene sottoposto a Boxing e quindi copiato.When copying from a reference-type array to a value-type array, each element is unboxed and then copied. Quando si esegue la copia da una matrice di tipo valore a una matrice di tipo riferimento, ogni elemento viene sottoposto a Boxing e quindi copiato.When copying from a value-type array to a reference-type array, each element is boxed and then copied.

  • Quando si esegue la copia da una matrice di tipo riferimento o valore a Object una matrice, Object viene creato un oggetto per conservare ogni valore o riferimento e quindi copiarlo.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. Quando si esegue la Object copia da una matrice a una matrice di tipo riferimento o valore e l'assegnazione non è possibile, InvalidCastException viene generata un'eccezione.When copying from an Object array to a reference-type or value-type array and the assignment is not possible, an InvalidCastException is thrown.

  • Se sourceArray Objecte destinationArray sono entrambe matrici di tipo riferimento o sono entrambe matrici di tipo, viene eseguita una copia superficiale.If sourceArray and destinationArray are both reference-type arrays or are both arrays of type Object, a shallow copy is performed. Una copia superficiale di un Array oggetto è un Array nuovo oggetto che contiene i riferimenti agli stessi elementi Arraydell'oggetto originale.A shallow copy of an Array is a new Array containing references to the same elements as the original Array. Gli elementi stessi o qualsiasi elemento a cui fanno riferimento gli elementi non vengono copiati.The elements themselves or anything referenced by the elements are not copied. Al contrario, una copia completa di un Array oggetto copia gli elementi e tutti gli elementi a cui fanno riferimento direttamente o indirettamente.In contrast, a deep copy of an Array copies the elements and everything directly or indirectly referenced by the elements.

Se ArrayTypeMismatchException le matrici sono di tipi incompatibili, viene generata un'eccezione.An ArrayTypeMismatchException is thrown if the arrays are of incompatible types. La compatibilità tra tipi viene definita nel modo seguente:Type compatibility is defined as follows:

  • Un tipo è compatibile con se stesso.A type is compatible with itself.

  • Un tipo di valore è compatibile Object con e con un tipo di interfaccia implementato da tale tipo di valore.A value type is compatible with Object and with an interface type implemented by that value type. Un tipo di valore viene considerato connesso a un'interfaccia solo se implementa direttamente tale interfaccia.A value type is considered connected to an interface only if it implements that interface directly. I tipi disconnessi non sono compatibili.Disconnected types are not compatible.

  • Due tipi di valore intrinseci (predefiniti) sono compatibili se la copia dal tipo di origine al tipo di destinazione è una conversione verso un tipo di dati più ampio.Two intrinsic (predefined) value types are compatible if copying from the source type to the destination type is a widening conversion. Una conversione verso un tipo di dati più ampio non perde mai informazioni, mentre una conversione verso un tipo di dati più piccolo può perdereA widening conversion never loses information, whereas a narrowing conversion can lose information. Ad esempio, la conversione di un intero con segno a 32 bit in un intero con segno a 64 bit è una conversione verso un tipo di caratteri più ampio e la conversione di un intero con segno a 64 bit in un intero con segno a 32 bit è una conversione verso un tipo di caratteri più piccoloFor 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. Per ulteriori informazioni sulle conversioni, vedere Convert.For more information about conversions, see Convert.

  • Un tipo di valore non intrinseco (definito dall'utente) è compatibile solo con se stesso.A nonintrinsic (user-defined) value type is compatible only with itself.

  • Le enumerazioni hanno una conversione implicita in Enum e nel relativo tipo sottostante.Enumerations have an implicit conversion to Enum and to their underlying type.

Se ogni elemento in sourceArray richiede un oggetto abbassato (ad esempio, da una classe base a una classe derivata o da un'interfaccia a un oggetto) e non è possibile eseguire il cast di uno o destinationArraypiù elementi InvalidCastException al tipo corrispondente in, viene generata un'eccezione.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.

Se questo metodo genera un'eccezione durante la copia, lo stato destinationArray di non è definito.If this method throws an exception while copying, the state of destinationArray is undefined.

Questo metodo è un'operazione On(), dove n è length.This method is an O(n) operation, where n is length.

Vedi anche

Copy(Array, Array, Int64) Copy(Array, Array, Int64) Copy(Array, Array, Int64) Copy(Array, Array, Int64)

Copia un intervallo di elementi da un oggetto Array a partire dal primo elemento e lo incolla in un altro oggetto Array a partire dal primo 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 lunghezza viene specificata come intero a 64 bit.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)

Parametri

sourceArray
Array Array Array Array

Oggetto Array che contiene i dati da copiare.The Array that contains the data to copy.

destinationArray
Array Array Array Array

Oggetto Array che riceve i dati.The Array that receives the data.

length
Int64 Int64 Int64 Int64

Intero a 64 bit che rappresenta il numero di elementi da copiare.A 64-bit integer that represents the number of elements to copy. L'intero deve essere compreso tra zero e MaxValue, inclusi.The integer must be between zero and MaxValue, inclusive.

Eccezioni

sourceArray è null.sourceArray is null.

In alternativa-or- destinationArray è null.destinationArray is null.

sourceArray e destinationArray hanno classificazioni diverse.sourceArray and destinationArray have different ranks.

I tipi di sourceArray e destinationArray sono incompatibili.sourceArray and destinationArray are of incompatible types.

Non è possibile eseguire il cast di almeno un elemento in sourceArray al tipo di destinationArray.At least one element in sourceArray cannot be cast to the type of destinationArray.

length è maggiore del numero di elementi in sourceArray.length is greater than the number of elements in sourceArray.

In alternativa-or- length è maggiore del numero di elementi in destinationArray.length is greater than the number of elements in destinationArray.

Commenti

I sourceArray parametri destinationArray e devono avere lo stesso numero di dimensioni.The sourceArray and destinationArray parameters must have the same number of dimensions. Inoltre, destinationArray deve essere già stato dimensionato e deve avere un numero sufficiente di elementi per contenere i dati copiati.In addition, destinationArray must already have been dimensioned and must have a sufficient number of elements to accommodate the copied data.

Quando si esegue la copia tra matrici multidimensionali, la matrice si comporta come una matrice unidimensionale lunga, in cui le righe o le colonne sono concettualmente definite end-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. Se, ad esempio, una matrice include tre righe (o colonne) con quattro elementi ciascuno, la copia di sei elementi dall'inizio della matrice comporterebbe la copia di tutti e quattro gli elementi della prima riga (o colonna) e dei primi due elementi della seconda riga o colonna.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).

Se sourceArray sourceArray destinationArray e destinationArray si sovrappongono, questo metodo si comporta come se i valori originali di fossero conservati in una posizione temporanea prima di essere sovrascritti.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++]

Questo metodo è equivalente alla funzioneC++ memmoveC/standard, non. memcpyThis method is equivalent to the standard C/C++ function memmove, not memcpy.

Le matrici possono essere matrici di tipi di riferimento o matrici di tipi di valore.The arrays can be reference-type arrays or value-type arrays. Il tipo downcast viene eseguito, come richiesto.Type downcasting is performed, as required.

  • Quando si esegue la copia da una matrice di tipo riferimento a una matrice di tipo valore, ogni elemento viene sottoposto a Boxing e quindi copiato.When copying from a reference-type array to a value-type array, each element is unboxed and then copied. Quando si esegue la copia da una matrice di tipo valore a una matrice di tipo riferimento, ogni elemento viene sottoposto a Boxing e quindi copiato.When copying from a value-type array to a reference-type array, each element is boxed and then copied.

  • Quando si esegue la copia da una matrice di tipo riferimento o valore a Object una matrice, Object viene creato un oggetto per conservare ogni valore o riferimento e quindi copiarlo.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. Quando si esegue la Object copia da una matrice a una matrice di tipo riferimento o valore e l'assegnazione non è possibile, InvalidCastException viene generata un'eccezione.When copying from an Object array to a reference-type or value-type array and the assignment is not possible, an InvalidCastException is thrown.

  • Se sourceArray Objecte destinationArray sono entrambe matrici di tipo riferimento o sono entrambe matrici di tipo, viene eseguita una copia superficiale.If sourceArray and destinationArray are both reference-type arrays or are both arrays of type Object, a shallow copy is performed. Una copia superficiale di un Array oggetto è un Array nuovo oggetto che contiene i riferimenti agli stessi elementi Arraydell'oggetto originale.A shallow copy of an Array is a new Array containing references to the same elements as the original Array. Gli elementi stessi o qualsiasi elemento a cui fanno riferimento gli elementi non vengono copiati.The elements themselves or anything referenced by the elements are not copied. Al contrario, una copia completa di un Array oggetto copia gli elementi e tutti gli elementi a cui fanno riferimento direttamente o indirettamente.In contrast, a deep copy of an Array copies the elements and everything directly or indirectly referenced by the elements.

Se ArrayTypeMismatchException le matrici sono di tipi incompatibili, viene generata un'eccezione.An ArrayTypeMismatchException is thrown if the arrays are of incompatible types. La compatibilità tra tipi viene definita nel modo seguente:Type compatibility is defined as follows:

  • Un tipo è compatibile con se stesso.A type is compatible with itself.

  • Un tipo di valore è compatibile Object con e con un tipo di interfaccia implementato da tale tipo di valore.A value type is compatible with Object and with an interface type implemented by that value type. Un tipo di valore viene considerato connesso a un'interfaccia solo se implementa direttamente tale interfaccia.A value type is considered connected to an interface only if it implements that interface directly. I tipi disconnessi non sono compatibili.Disconnected types are not compatible.

  • Due tipi di valore intrinseci (predefiniti) sono compatibili se la copia dal tipo di origine al tipo di destinazione è una conversione verso un tipo di dati più ampio.Two intrinsic (predefined) value types are compatible if copying from the source type to the destination type is a widening conversion. Una conversione verso un tipo di dati più ampio non perde mai informazioni, mentre una conversione verso un tipo di dati più piccolo può perdereA widening conversion never loses information, whereas a narrowing conversion can lose information. Ad esempio, la conversione di un intero con segno a 32 bit in un intero con segno a 64 bit è una conversione verso un tipo di caratteri più ampio e la conversione di un intero con segno a 64 bit in un intero con segno a 32 bit è una conversione verso un tipo di caratteri più piccoloFor 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. Per ulteriori informazioni sulle conversioni, vedere Convert.For more information about conversions, see Convert.

  • Un tipo di valore non intrinseco (definito dall'utente) è compatibile solo con se stesso.A nonintrinsic (user-defined) value type is compatible only with itself.

  • Le enumerazioni hanno una conversione implicita in Enum e nel relativo tipo sottostante.Enumerations have an implicit conversion to Enum and to their underlying type.

Se ogni elemento in sourceArray richiede un oggetto abbassato (ad esempio, da una classe base a una classe derivata o da un'interfaccia a un oggetto) e non è possibile eseguire il cast di uno o destinationArraypiù elementi InvalidCastException al tipo corrispondente in, viene generata un'eccezione.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.

Se questo metodo genera un'eccezione durante la copia, lo stato destinationArray di non è definito.If this method throws an exception while copying, the state of destinationArray is undefined.

Questo metodo è un'operazione On(), dove n è length.This method is an O(n) operation, where n is length.

Vedi anche

Copy(Array, Array, Int32) Copy(Array, Array, Int32) Copy(Array, Array, Int32) Copy(Array, Array, Int32)

Copia un intervallo di elementi da un oggetto Array a partire dal primo elemento e lo incolla in un altro oggetto Array a partire dal primo 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 lunghezza viene specificata come intero a 32 bit.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)

Parametri

sourceArray
Array Array Array Array

Oggetto Array che contiene i dati da copiare.The Array that contains the data to copy.

destinationArray
Array Array Array Array

Oggetto Array che riceve i dati.The Array that receives the data.

length
Int32 Int32 Int32 Int32

Intero a 32 bit che rappresenta il numero degli elementi da copiare.A 32-bit integer that represents the number of elements to copy.

Eccezioni

sourceArray è null.sourceArray is null.

-oppure--or- destinationArray è null.destinationArray is null.

sourceArray e destinationArray hanno classificazioni diverse.sourceArray and destinationArray have different ranks.

I tipi di sourceArray e destinationArray sono incompatibili.sourceArray and destinationArray are of incompatible types.

Non è possibile eseguire il cast di almeno un elemento in sourceArray al tipo di destinationArray.At least one element in sourceArray cannot be cast to the type of destinationArray.

length è maggiore del numero di elementi in sourceArray.length is greater than the number of elements in sourceArray.

-oppure--or- length è maggiore del numero di elementi in destinationArray.length is greater than the number of elements in destinationArray.

Commenti

I sourceArray parametri destinationArray e devono avere lo stesso numero di dimensioni.The sourceArray and destinationArray parameters must have the same number of dimensions. Inoltre, destinationArray deve essere già stato dimensionato e deve avere un numero sufficiente di elementi per contenere i dati copiati.In addition, destinationArray must already have been dimensioned and must have a sufficient number of elements to accommodate the copied data.

Quando si esegue la copia tra matrici multidimensionali, la matrice si comporta come una matrice unidimensionale lunga, in cui le righe o le colonne sono concettualmente definite end-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. Se, ad esempio, una matrice include tre righe (o colonne) con quattro elementi ciascuno, la copia di sei elementi dall'inizio della matrice comporterebbe la copia di tutti e quattro gli elementi della prima riga (o colonna) e dei primi due elementi della seconda riga o colonna.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).

Se sourceArray sourceArray destinationArray e destinationArray si sovrappongono, questo metodo si comporta come se i valori originali di fossero conservati in una posizione temporanea prima di essere sovrascritti.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++]

Questo metodo è equivalente alla funzioneC++ memmoveC/standard, non. memcpyThis method is equivalent to the standard C/C++ function memmove, not memcpy.

Le matrici possono essere matrici di tipi di riferimento o matrici di tipi di valore.The arrays can be reference-type arrays or value-type arrays. Il tipo downcast viene eseguito, come richiesto.Type downcasting is performed, as required.

  • Quando si esegue la copia da una matrice di tipo riferimento a una matrice di tipo valore, ogni elemento viene sottoposto a Boxing e quindi copiato.When copying from a reference-type array to a value-type array, each element is unboxed and then copied. Quando si esegue la copia da una matrice di tipo valore a una matrice di tipo riferimento, ogni elemento viene sottoposto a Boxing e quindi copiato.When copying from a value-type array to a reference-type array, each element is boxed and then copied.

  • Quando si esegue la copia da una matrice di tipo riferimento o valore a Object una matrice, Object viene creato un oggetto per conservare ogni valore o riferimento e quindi copiarlo.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. Quando si esegue la Object copia da una matrice a una matrice di tipo riferimento o valore e l'assegnazione non è possibile, InvalidCastException viene generata un'eccezione.When copying from an Object array to a reference-type or value-type array and the assignment is not possible, an InvalidCastException is thrown.

  • Se sourceArray Objecte destinationArray sono entrambe matrici di tipo riferimento o sono entrambe matrici di tipo, viene eseguita una copia superficiale.If sourceArray and destinationArray are both reference-type arrays or are both arrays of type Object, a shallow copy is performed. Una copia superficiale di un Array oggetto è un Array nuovo oggetto che contiene i riferimenti agli stessi elementi Arraydell'oggetto originale.A shallow copy of an Array is a new Array containing references to the same elements as the original Array. Gli elementi stessi o qualsiasi elemento a cui fanno riferimento gli elementi non vengono copiati.The elements themselves or anything referenced by the elements are not copied. Al contrario, una copia completa di un Array oggetto copia gli elementi e tutti gli elementi a cui fanno riferimento direttamente o indirettamente.In contrast, a deep copy of an Array copies the elements and everything directly or indirectly referenced by the elements.

Se ArrayTypeMismatchException le matrici sono di tipi incompatibili, viene generata un'eccezione.An ArrayTypeMismatchException is thrown if the arrays are of incompatible types. La compatibilità tra tipi viene definita nel modo seguente:Type compatibility is defined as follows:

  • Un tipo è compatibile con se stesso.A type is compatible with itself.

  • Un tipo di valore è compatibile Object con e con un tipo di interfaccia implementato da tale tipo di valore.A value type is compatible with Object and with an interface type implemented by that value type. Un tipo di valore viene considerato connesso a un'interfaccia solo se implementa direttamente tale interfaccia.A value type is considered connected to an interface only if it implements that interface directly. I tipi disconnessi non sono compatibili.Disconnected types are not compatible.

  • Due tipi di valore intrinseci (predefiniti) sono compatibili se la copia dal tipo di origine al tipo di destinazione è una conversione verso un tipo di dati più ampio.Two intrinsic (predefined) value types are compatible if copying from the source type to the destination type is a widening conversion. Una conversione verso un tipo di dati più ampio non perde mai informazioni, mentre una conversione verso un tipo di dati più piccolo può perdereA widening conversion never loses information, whereas a narrowing conversion can lose information. Ad esempio, la conversione di un intero con segno a 32 bit in un intero con segno a 64 bit è una conversione verso un tipo di caratteri più ampio e la conversione di un intero con segno a 64 bit in un intero con segno a 32 bit è una conversione verso un tipo di caratteri più piccoloFor 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. Per ulteriori informazioni sulle conversioni, vedere Convert.For more information about conversions, see Convert.

  • Un tipo di valore non intrinseco (definito dall'utente) è compatibile solo con se stesso.A nonintrinsic (user-defined) value type is compatible only with itself.

  • Le enumerazioni hanno una conversione implicita in Enum e nel relativo tipo sottostante.Enumerations have an implicit conversion to Enum and to their underlying type.

Se ogni elemento in sourceArray richiede un oggetto abbassato (ad esempio, da una classe base a una classe derivata o da un'interfaccia a un oggetto) e non è possibile eseguire il cast di uno o destinationArraypiù elementi InvalidCastException al tipo corrispondente in, viene generata un'eccezione.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.

Se questo metodo genera un'eccezione durante la copia, lo stato destinationArray di non è definito.If this method throws an exception while copying, the state of destinationArray is undefined.

Questo metodo è un'operazione On(), dove n è length.This method is an O(n) operation, where n is length.

Vedi anche

Si applica a