Array.Copy Metodo

Riferimento

Definizione

Spazio dei nomi:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

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à.

Overload

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. La lunghezza e gli indici vengono specificati come interi a 64 bit.
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. La lunghezza e gli indici vengono specificati come interi a 32 bit.
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. La lunghezza viene specificata come intero a 32 bit.
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. La lunghezza viene specificata come intero a 64 bit.

Esempio

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

open System

let printValues (myArr: 'a []) =
    let mutable i = 0;
    let cols = myArr.GetLength(myArr.Rank - 1)
    for item in myArr do
        if i < cols then
            i <- i + 1
        else
            printfn ""
            i <- 1
        printf $"\t{item}"
    printfn ""

 // Creates and initializes a new Array of type int.
let myIntArray = [| 1..5 |]

// Creates and initializes a new Array of type Object.
let myObjArray = Array.init 5 (fun i -> i + 26 :> obj)

// Displays the initial values of both arrays.
printfn "int array:"
printValues myIntArray 
printfn "Object array:"
printValues myObjArray

// Copies the first element from the int 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 int array.
Array.Copy(myObjArray, myObjArray.GetUpperBound 0 - 1, myIntArray, myIntArray.GetUpperBound 0 - 1, 2)

// Displays the values of the modified arrays.
printfn "int array - Last two elements should now be the same as Object array:"
printValues myIntArray 
printfn "Object array - First element should now be the same as int array:"
printValues myObjArray


// This code produces the following output.
//     int array:
//         1    2    3    4    5
//     Object array:
//         26    27    28    29    30
//     int 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 int array:
//         1    27    28    29    30

using System;
public class SamplesArray  {

   public static void Main()  {

      // Creates and initializes a new Array of type int.
      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( "int array:" );
      PrintValues( myIntArray );
      Console.WriteLine( "Object array:" );
      PrintValues( myObjArray );

      // Copies the first element from the int 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 int array.
      Array.Copy( myObjArray, myObjArray.GetUpperBound(0) - 1, myIntArray, myIntArray.GetUpperBound(0) - 1, 2 );

      // Displays the values of the modified arrays.
      Console.WriteLine( "int 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 int 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.

int array:
    1    2    3    4    5
Object array:
    26    27    28    29    30
int 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 int array:
    1    27    28    29    30
*/

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

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

Source:: Array.cs

Source:: Array.cs

Source:: Array.cs

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. La lunghezza e gli indici vengono specificati come interi a 64 bit.

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

Oggetto Array che contiene i dati da copiare.

sourceIndex: Int64

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

destinationArray: Array

Oggetto Array che riceve i dati.

destinationIndex: Int64

Intero a 64 bit che rappresenta l'indice in destinationArray da cui viene avviata l'archiviazione.

length: Int64

Intero a 64 bit che rappresenta il numero di elementi da copiare. L'intero deve essere compreso tra zero e Int32.MaxValue, inclusivo.

Eccezioni

ArgumentNullException

sourceArray è null.

-oppure-

destinationArray è null.

RankException

sourceArray e destinationArray hanno classificazioni diverse.

ArrayTypeMismatchException

I tipi di sourceArray e destinationArray sono incompatibili.

InvalidCastException

Non è possibile eseguire il cast di almeno un elemento in sourceArray al tipo di destinationArray.

ArgumentOutOfRangeException

sourceIndex non è compreso nell'intervallo di indici validi per sourceArray.

-oppure-

destinationIndex non è compreso nell'intervallo di indici validi per destinationArray.

-oppure-

length è minore di 0 o maggiore di Int32.MaxValue.

ArgumentException

length è maggiore del numero di elementi compresi tra sourceIndex e la fine di sourceArray.

-oppure-

length è maggiore del numero di elementi compresi tra destinationIndex e la fine di destinationArray.

Commenti

I sourceArray parametri e destinationArray devono avere lo stesso numero di dimensioni. Inoltre, destinationArray deve essere già stato ridimensionato e deve avere un numero sufficiente di elementi a partire dalla destinationIndex posizione per ospitare i dati copiati.

Quando si copiano tra matrici multidimensionali, la matrice si comporta come una matrice unidimensionale lunga, in cui le righe (o le colonne) sono concettualmente disposte end-to-end. Ad esempio, se una matrice dispone di tre righe (o colonne) con quattro elementi ognuno, copiando sei elementi dall'inizio della matrice, copiare tutti e quattro gli elementi della prima riga (o colonna) e i primi due elementi della seconda riga (o colonna). Per iniziare a copiare 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.

Se sourceArray e destinationArray si sovrappone, questo metodo si comporta come se i valori originali di siano stati mantenuti in una posizione temporanea prima destinationArray di sourceArray essere sovrascritti.

[C++]

Questo metodo equivale alla funzione memmoveC/C++ standard, non memcpy.

Le matrici possono essere matrici di tipo riferimento o matrici di tipo valore. Il downcast dei tipi viene eseguito, in base alle esigenze.

Quando si copia da una matrice di tipo riferimento a una matrice di tipo valore, ogni elemento viene deselezionato e quindi copiato. Quando si copia da una matrice di tipo valore a una matrice di tipo riferimento, ogni elemento viene casellato e quindi copiato.
Quando si copia da una matrice di tipo riferimento o di tipo valore a una Object matrice, viene creato un oggetto Object per contenere ogni valore o riferimento e quindi copiato. Quando si copia da una matrice a una Object matrice di tipo riferimento o di tipo valore e l'assegnazione non è possibile, viene generata un'assegnazione InvalidCastException .
Se sourceArray e destinationArray sono entrambe matrici di tipo riferimento o entrambe le matrici di tipo Object, viene eseguita una copia superficiale. Una copia superficiale di un oggetto Array è un nuovo Array oggetto contenente riferimenti agli stessi elementi dell'originale Array. Gli elementi stessi o qualsiasi elemento a cui fa riferimento gli elementi non vengono copiati. Al contrario, una copia profonda di un Array oggetto copia gli elementi e tutto direttamente o indirettamente a cui fa riferimento gli elementi.

Viene ArrayTypeMismatchException generato se le matrici sono di tipi incompatibili. La compatibilità dei tipi è definita come segue:

Un tipo è compatibile con se stesso.
Un tipo di valore è compatibile con Object e con un tipo di interfaccia implementato da tale tipo di valore. Un tipo di valore viene considerato connesso a un'interfaccia solo se implementa direttamente tale interfaccia. I tipi disconnessi non sono compatibili.
Due tipi di valore intrinseci (predefiniti) sono compatibili se la copia dal tipo di origine al tipo di destinazione è una conversione in estensione. Una conversione estesa non perde mai informazioni, mentre una conversione ristretta può perdere informazioni. Ad esempio, la conversione di un intero con segno a 32 bit in un intero con segno a 64 bit è una conversione con estensione e la conversione di un intero con segno a 64 bit in un intero con segno a 32 bit è una conversione con segno a 32 bit. Per altre informazioni sulle conversioni, vedere Convert.
Un tipo di valore non trinsico (definito dall'utente) è compatibile solo con se stesso.
Le enumerazioni hanno una conversione implicita in Enum e nel tipo sottostante.

Se ogni elemento in sourceArray richiede un downcast (ad esempio, da una classe di base a una classe derivata o da un'interfaccia a un oggetto) e uno o più elementi non possono essere inviati al tipo corrispondente in destinationArray, viene generato un InvalidCastException oggetto .

Se questo metodo genera un'eccezione durante la copia, lo stato di destinationArray è indefinito.

Questo metodo è un'operazione O(n), dove n è length.

Vedi anche

Si applica a

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

Source:: Array.CoreCLR.cs

Source:: Array.cs

Source:: Array.cs

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

Oggetto Array che contiene i dati da copiare.

sourceIndex: Int32

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

destinationArray: Array

Oggetto Array che riceve i dati.

destinationIndex: Int32

Intero a 32 bit che rappresenta l'indice in destinationArray da cui viene avviata l'archiviazione.

length: Int32

Intero a 32 bit che rappresenta il numero degli elementi da copiare.

Eccezioni

ArgumentNullException

sourceArray è null.

-oppure-

destinationArray è null.

RankException

sourceArray e destinationArray hanno classificazioni diverse.

ArrayTypeMismatchException

I tipi di sourceArray e destinationArray sono incompatibili.

InvalidCastException

Non è possibile eseguire il cast di almeno un elemento in sourceArray al tipo di destinationArray.

ArgumentOutOfRangeException

sourceIndex è minore del limite inferiore della prima dimensione di sourceArray.

-oppure-

destinationIndex è minore del limite inferiore della prima dimensione di destinationArray.

-oppure-

length è minore di zero.

ArgumentException

length è maggiore del numero di elementi compresi tra sourceIndex e la fine di sourceArray.

-oppure-

length è maggiore del numero di elementi compresi tra destinationIndex e la fine di destinationArray.

Commenti

[C++]

Questo metodo equivale alla funzione memmoveC/C++ standard, non memcpy.

Le matrici possono essere matrici di tipo riferimento o matrici di tipo valore. Il downcast dei tipi viene eseguito, in base alle esigenze.

Quando si copia da una matrice di tipo riferimento a una matrice di tipo valore, ogni elemento viene deselezionato e quindi copiato. Quando si copia da una matrice di tipo valore a una matrice di tipo riferimento, ogni elemento viene casellato e quindi copiato.
Quando si copia da una matrice di tipo riferimento o di tipo valore a una Object matrice, viene creato un oggetto Object per contenere ogni valore o riferimento e quindi copiato. Quando si copia da una matrice a una Object matrice di tipo riferimento o di tipo valore e l'assegnazione non è possibile, viene generata un'assegnazione InvalidCastException .
Se sourceArray e destinationArray sono entrambe matrici di tipo riferimento o entrambe le matrici di tipo Object, viene eseguita una copia superficiale. Una copia superficiale di un oggetto Array è un nuovo Array oggetto contenente riferimenti agli stessi elementi dell'originale Array. Gli elementi stessi o qualsiasi elemento a cui fa riferimento gli elementi non vengono copiati. Al contrario, una copia profonda di un Array oggetto copia gli elementi e tutto direttamente o indirettamente a cui fa riferimento gli elementi.

Viene ArrayTypeMismatchException generato se le matrici sono di tipi incompatibili. La compatibilità dei tipi è definita come segue:

Un tipo è compatibile con se stesso.
Un tipo di valore è compatibile con Object e con un tipo di interfaccia implementato da tale tipo di valore. Un tipo di valore viene considerato connesso a un'interfaccia solo se implementa direttamente tale interfaccia. I tipi disconnessi non sono compatibili.
Due tipi di valore intrinseci (predefiniti) sono compatibili se la copia dal tipo di origine al tipo di destinazione è una conversione in estensione. Una conversione estesa non perde mai informazioni, mentre una conversione ristretta può perdere informazioni. Ad esempio, la conversione di un intero con segno a 32 bit in un intero con segno a 64 bit è una conversione con estensione e la conversione di un intero con segno a 64 bit in un intero con segno a 32 bit è una conversione con segno a 32 bit. Per altre informazioni sulle conversioni, vedere Convert.
Un tipo di valore non trinsico (definito dall'utente) è compatibile solo con se stesso.
Le enumerazioni hanno una conversione implicita in Enum e nel tipo sottostante.

Se questo metodo genera un'eccezione durante la copia, lo stato di destinationArray è indefinito.

Questo metodo è un'operazione O(n), dove n è length.

Vedi anche

Si applica a

Copy(Array, Array, Int32)

Source:: Array.CoreCLR.cs

Source:: Array.cs

Source:: Array.cs

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. La lunghezza viene specificata come intero a 32 bit.

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

Oggetto Array che contiene i dati da copiare.

destinationArray: Array

Oggetto Array che riceve i dati.

length: Int32

Intero a 32 bit che rappresenta il numero degli elementi da copiare.

Eccezioni

ArgumentNullException

sourceArray è null.

-oppure-

destinationArray è null.

RankException

sourceArray e destinationArray hanno classificazioni diverse.

ArrayTypeMismatchException

I tipi di sourceArray e destinationArray sono incompatibili.

InvalidCastException

Non è possibile eseguire il cast di almeno un elemento in sourceArray al tipo di destinationArray.

ArgumentOutOfRangeException

length è minore di zero.

ArgumentException

length è maggiore del numero di elementi in sourceArray.

-oppure-

length è maggiore del numero di elementi in destinationArray.

Commenti

Quando si copiano tra matrici multidimensionali, la matrice si comporta come una matrice unidimensionale lunga, in cui le righe (o le colonne) sono concettualmente disposte alla fine. Ad esempio, se una matrice dispone di tre righe (o colonne) con quattro elementi ognuno, copiando sei elementi dall'inizio della matrice, copiare tutti e quattro gli elementi della prima riga (o colonna) e i primi due elementi della seconda riga (o colonna).

[C++]

Questo metodo equivale alla funzione memmoveC/C++ standard, non memcpy.

Le matrici possono essere matrici di tipo riferimento o matrici di tipo valore. Il downcast dei tipi viene eseguito, in base alle esigenze.

Quando si copia da una matrice di tipo riferimento a una matrice di tipo valore, ogni elemento viene deselezionato e quindi copiato. Quando si copia da una matrice di tipo valore a una matrice di tipo riferimento, ogni elemento viene casellato e quindi copiato.
Quando si copia da una matrice di tipo riferimento o di tipo valore a una Object matrice, viene creato un oggetto Object per contenere ogni valore o riferimento e quindi copiato. Quando si copia da una matrice a una Object matrice di tipo riferimento o di tipo valore e l'assegnazione non è possibile, viene generata un'assegnazione InvalidCastException .
Se sourceArray e destinationArray sono entrambe matrici di tipo riferimento o entrambe le matrici di tipo Object, viene eseguita una copia superficiale. Una copia superficiale di un oggetto Array è un nuovo Array oggetto contenente riferimenti agli stessi elementi dell'originale Array. Gli elementi stessi o qualsiasi elemento a cui fa riferimento gli elementi non vengono copiati. Al contrario, una copia profonda di un Array oggetto copia gli elementi e tutto direttamente o indirettamente a cui fa riferimento gli elementi.

Viene ArrayTypeMismatchException generato se le matrici sono di tipi incompatibili. La compatibilità dei tipi è definita come segue:

Un tipo è compatibile con se stesso.
Un tipo di valore è compatibile con Object e con un tipo di interfaccia implementato da tale tipo di valore. Un tipo di valore viene considerato connesso a un'interfaccia solo se implementa direttamente tale interfaccia. I tipi disconnessi non sono compatibili.
Due tipi di valore intrinseci (predefiniti) sono compatibili se la copia dal tipo di origine al tipo di destinazione è una conversione in estensione. Una conversione estesa non perde mai informazioni, mentre una conversione ristretta può perdere informazioni. Ad esempio, la conversione di un intero con segno a 32 bit in un intero con segno a 64 bit è una conversione con estensione e la conversione di un intero con segno a 64 bit in un intero con segno a 32 bit è una conversione con segno a 32 bit. Per altre informazioni sulle conversioni, vedere Convert.
Un tipo di valore non trinsico (definito dall'utente) è compatibile solo con se stesso.
Le enumerazioni hanno una conversione implicita in Enum e nel tipo sottostante.

Se questo metodo genera un'eccezione durante la copia, lo stato di destinationArray è indefinito.

Questo metodo è un'operazione O(n), dove n è length.

Vedi anche

Si applica a

Copy(Array, Array, Int64)

Source:: Array.cs

Source:: Array.cs

Source:: Array.cs

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

Oggetto Array che contiene i dati da copiare.

destinationArray: Array

Oggetto Array che riceve i dati.

length: Int64

Intero a 64 bit che rappresenta il numero di elementi da copiare. L'intero deve essere compreso tra zero e Int32.MaxValue, inclusivo.

Eccezioni

ArgumentNullException

sourceArray è null.

-oppure-

destinationArray è null.

RankException

sourceArray e destinationArray hanno classificazioni diverse.

ArrayTypeMismatchException

I tipi di sourceArray e destinationArray sono incompatibili.

InvalidCastException

Non è possibile eseguire il cast di almeno un elemento in sourceArray al tipo di destinationArray.

ArgumentOutOfRangeException

length è minore di 0 o maggiore di Int32.MaxValue.

ArgumentException

length è maggiore del numero di elementi in sourceArray.

-oppure-

length è maggiore del numero di elementi in destinationArray.

Commenti

[C++]

Questo metodo equivale alla funzione memmoveC/C++ standard, non memcpy.

Le matrici possono essere matrici di tipo riferimento o matrici di tipo valore. Il downcast dei tipi viene eseguito, in base alle esigenze.

Quando si copia da una matrice di tipo riferimento a una matrice di tipo valore, ogni elemento viene deselezionato e quindi copiato. Quando si copia da una matrice di tipo valore a una matrice di tipo riferimento, ogni elemento viene casellato e quindi copiato.
Quando si copia da una matrice di tipo riferimento o di tipo valore a una Object matrice, viene creato un oggetto Object per contenere ogni valore o riferimento e quindi copiato. Quando si copia da una matrice a una Object matrice di tipo riferimento o di tipo valore e l'assegnazione non è possibile, viene generata un'assegnazione InvalidCastException .
Se sourceArray e destinationArray sono entrambe matrici di tipo riferimento o entrambe le matrici di tipo Object, viene eseguita una copia superficiale. Una copia superficiale di un oggetto Array è un nuovo Array oggetto contenente riferimenti agli stessi elementi dell'originale Array. Gli elementi stessi o qualsiasi elemento a cui fa riferimento gli elementi non vengono copiati. Al contrario, una copia profonda di un Array oggetto copia gli elementi e tutto direttamente o indirettamente a cui fa riferimento gli elementi.

Viene ArrayTypeMismatchException generato se le matrici sono di tipi incompatibili. La compatibilità dei tipi è definita come segue:

Un tipo è compatibile con se stesso.
Un tipo di valore è compatibile con Object e con un tipo di interfaccia implementato da tale tipo di valore. Un tipo di valore viene considerato connesso a un'interfaccia solo se implementa direttamente tale interfaccia. I tipi disconnessi non sono compatibili.
Due tipi di valore intrinseci (predefiniti) sono compatibili se la copia dal tipo di origine al tipo di destinazione è una conversione in estensione. Una conversione estesa non perde mai informazioni, mentre una conversione ristretta può perdere informazioni. Ad esempio, la conversione di un intero con segno a 32 bit in un intero con segno a 64 bit è una conversione con estensione e la conversione di un intero con segno a 64 bit in un intero con segno a 32 bit è una conversione con segno a 32 bit. Per altre informazioni sulle conversioni, vedere Convert.
Un tipo di valore non trinsico (definito dall'utente) è compatibile solo con se stesso.
Le enumerazioni hanno una conversione implicita in Enum e nel tipo sottostante.

Se questo metodo genera un'eccezione durante la copia, lo stato di destinationArray è indefinito.

Questo metodo è un'operazione O(n), dove n è length.

Vedi anche

Si applica a

Array.Copy Metodo

Definizione

Overload

Esempio

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

Parametri

Eccezioni

Commenti

Vedi anche

Si applica a

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

Parametri

Eccezioni

Commenti

Vedi anche

Si applica a

Copy(Array, Array, Int32)

Parametri

Eccezioni

Commenti

Vedi anche

Si applica a

Copy(Array, Array, Int64)

Parametri

Eccezioni

Commenti

Vedi anche

Si applica a

Commenti e suggerimenti

Risorse aggiuntive