Array.Copy Metodo

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

Overload

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.

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

Esempio

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

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

sourceArray è null.

-oppure-

destinationArray è null.

sourceArray e destinationArray hanno classificazioni diverse.

I tipi di sourceArray e destinationArray sono incompatibili.

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

length è minore di zero.

length è maggiore del numero di elementi in sourceArray.

-oppure-

length è maggiore del numero di elementi in destinationArray.

Commenti

I sourceArray parametri e devono avere lo stesso numero di destinationArray dimensioni. Inoltre, deve essere già stato dimensionato e deve avere un numero sufficiente di destinationArray elementi per contenere i dati copiati.

Quando si esegue la copia tra matrici multidimensionali, la matrice si comporta come una lunga matrice unidimensionale, in cui le righe (o le colonne) sono concettualmente disposte end-to-end. Ad esempio, se una matrice ha tre righe (o colonne) con quattro elementi ciascuno, copiando sei elementi dall'inizio della matrice verranno copiati tutti e quattro gli elementi della prima riga (o colonna) e dei primi due elementi della seconda riga (o colonna).

Se sourceArray e si sovrappongono, questo metodo si comporta come se i valori originali di fossero mantenuti in una posizione temporanea destinationArray prima della sourceArray destinationArray sovrascrittura.

[C++]

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

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 esegue la copia da una matrice di tipo riferimento a una matrice di tipo valore, ogni elemento viene unboxed e quindi copiato. Quando si copia da una matrice di tipo valore a una matrice di tipo riferimento, ogni elemento viene boxed e quindi copiato.

  • Quando si copia da una matrice reference-type o value-type a una matrice, viene creato un oggetto per contenere ogni valore o riferimento Object Object e quindi copiato. Quando si copia da una matrice a una matrice reference-type o value-type e l'assegnazione non è Object possibile, viene InvalidCastException generata un'eccezione .

  • Se e sono entrambe matrici di tipo riferimento o sono entrambe matrici di sourceArray tipo , viene eseguita una copia destinationArray Object superficiale. Una copia superficiale di Array un oggetto è un nuovo contenente riferimenti agli stessi elementi Array dell'oggetto Array originale. Gli elementi stessi o qualsiasi elemento a cui fanno riferimento gli elementi non vengono copiati. Al contrario, una copia completa di un copia gli elementi e tutti gli elementi a cui gli elementi fanno riferimento direttamente o Array indirettamente.

Viene ArrayTypeMismatchException generata un'eccezione se le matrici sono di tipi incompatibili. La compatibilità dei tipi è definita nel modo seguente:

  • Un tipo è compatibile con se stesso.

  • Un tipo valore è compatibile con Object e con un tipo di interfaccia implementato da tale tipo di valore. Un tipo valore viene considerato connesso a un'interfaccia solo se implementa direttamente tale interfaccia. I tipi disconnessi non sono compatibili.

  • Due tipi valore intrinseci (predefiniti) sono compatibili se la copia dal tipo di origine al tipo di destinazione è una conversione più ampia. Una conversione più ampia non perde mai le informazioni, mentre una conversione verso un tipo più ridotto 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 più ampia e la conversione di un intero con segno a 64 bit in un intero con segno a 32 bit è una conversione verso un tipo più piccolo. Per altre informazioni sulle conversioni, vedere Convert .

  • Un tipo di valore non unintrinsic (definito dall'utente) è compatibile solo con se stesso.

  • Le enumerazioni hanno una conversione Enum implicita in e nel tipo sottostante.

Se ogni elemento in richiede un downcast(ad esempio, da una classe di base a una classe derivata o da un'interfaccia a un oggetto) e non è possibile eseguire il cast di uno o più elementi al tipo corrispondente in , viene generata sourceArray destinationArray un'eccezione InvalidCastException .

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

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

Vedi anche

Si applica a

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.

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 MaxValue, inclusi.

Eccezioni

sourceArray è null.

-oppure-

destinationArray è null.

sourceArray e destinationArray hanno classificazioni diverse.

I tipi di sourceArray e destinationArray sono incompatibili.

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

length è minore di 0 o maggiore di MaxValue.

length è maggiore del numero di elementi in sourceArray.

-oppure-

length è maggiore del numero di elementi in destinationArray.

Commenti

I sourceArray parametri e devono avere lo stesso numero di destinationArray dimensioni. Inoltre, deve essere già stato dimensionato e deve avere un numero sufficiente di destinationArray elementi per contenere i dati copiati.

Quando si esegue la copia tra matrici multidimensionali, la matrice si comporta come una lunga matrice unidimensionale, in cui le righe (o le colonne) sono concettualmente disposte end-to-end. Ad esempio, se una matrice ha tre righe (o colonne) con quattro elementi ciascuno, copiando sei elementi dall'inizio della matrice verranno copiati tutti e quattro gli elementi della prima riga (o colonna) e dei primi due elementi della seconda riga (o colonna).

Se sourceArray e si sovrappongono, questo metodo si comporta come se i valori originali di fossero mantenuti in una posizione temporanea destinationArray prima della sourceArray destinationArray sovrascrittura.

[C++]

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

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 esegue la copia da una matrice di tipo riferimento a una matrice di tipo valore, ogni elemento viene unboxed e quindi copiato. Quando si copia da una matrice di tipo valore a una matrice di tipo riferimento, ogni elemento viene boxed e quindi copiato.

  • Quando si copia da una matrice reference-type o value-type a una matrice, viene creato un oggetto per contenere ogni valore o riferimento Object Object e quindi copiato. Quando si copia da una matrice a una matrice reference-type o value-type e l'assegnazione non è Object possibile, viene InvalidCastException generata un'eccezione .

  • Se e sono entrambe matrici di tipo riferimento o sono entrambe matrici di sourceArray tipo , viene eseguita una copia destinationArray Object superficiale. Una copia superficiale di Array un oggetto è un nuovo contenente riferimenti agli stessi elementi Array dell'oggetto Array originale. Gli elementi stessi o qualsiasi elemento a cui fanno riferimento gli elementi non vengono copiati. Al contrario, una copia completa di un copia gli elementi e tutti gli elementi a cui gli elementi fanno riferimento direttamente o Array indirettamente.

Viene ArrayTypeMismatchException generata un'eccezione se le matrici sono di tipi incompatibili. La compatibilità dei tipi è definita nel modo seguente:

  • Un tipo è compatibile con se stesso.

  • Un tipo valore è compatibile con Object e con un tipo di interfaccia implementato da tale tipo di valore. Un tipo valore viene considerato connesso a un'interfaccia solo se implementa direttamente tale interfaccia. I tipi disconnessi non sono compatibili.

  • Due tipi valore intrinseci (predefiniti) sono compatibili se la copia dal tipo di origine al tipo di destinazione è una conversione più ampia. Una conversione più ampia non perde mai informazioni, mentre una conversione verso un tipo più ridotto 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 più ampia e la conversione di un intero con segno a 64 bit in un intero con segno a 32 bit è una conversione verso un tipo più piccolo. Per altre informazioni sulle conversioni, vedere Convert .

  • Un tipo di valore non unintrinsic (definito dall'utente) è compatibile solo con se stesso.

  • Le enumerazioni hanno una conversione Enum implicita in e nel tipo sottostante.

Se ogni elemento in richiede un downcast(ad esempio, da una classe di base a una classe derivata o da un'interfaccia a un oggetto) e non è possibile eseguire il cast di uno o più elementi al tipo corrispondente in , viene generata sourceArray destinationArray un'eccezione InvalidCastException .

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

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

Vedi anche

Si applica a

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.

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

sourceArray è null.

-oppure-

destinationArray è null.

sourceArray e destinationArray hanno classificazioni diverse.

I tipi di sourceArray e destinationArray sono incompatibili.

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

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.

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 devono avere lo stesso numero di destinationArray dimensioni. Inoltre, deve essere già stato dimensionato e deve avere un numero sufficiente di elementi a partire dalla posizione per destinationArray destinationIndex contenere i dati copiati.

Quando si esegue la copia tra matrici multidimensionali, la matrice si comporta come una lunga matrice unidimensionale, in cui le righe (o le colonne) sono concettualmente disposti end-to-end. Ad esempio, se una matrice ha tre righe (o colonne) con quattro elementi ciascuno, copiando sei elementi dall'inizio della matrice verranno copiati tutti e quattro gli elementi della prima riga (o colonna) e dei primi due elementi della seconda riga (o colonna). Per iniziare la copia dal secondo elemento della terza riga (o colonna), deve essere il limite superiore della prima riga (o colonna) più la lunghezza della seconda riga sourceIndex (o colonna) più due.

Se sourceArray e si sovrappongono, questo metodo si comporta come se i valori originali di fossero mantenuti in una posizione temporanea destinationArray prima della sourceArray destinationArray sovrascrittura.

[C++]

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

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 esegue la copia da una matrice di tipo riferimento a una matrice di tipo valore, ogni elemento viene unboxed e quindi copiato. Quando si copia da una matrice di tipo valore a una matrice di tipo riferimento, ogni elemento viene boxed e quindi copiato.

  • Quando si copia da una matrice reference-type o value-type a una matrice, viene creato un oggetto per contenere ogni valore o riferimento Object Object e quindi copiato. Quando si copia da una matrice a una matrice reference-type o value-type e l'assegnazione non è Object possibile, viene InvalidCastException generata un'eccezione .

  • Se e sono entrambe matrici di tipo riferimento o sono entrambe matrici di sourceArray tipo , viene eseguita una copia destinationArray Object superficiale. Una copia superficiale di Array un oggetto è un nuovo contenente riferimenti agli stessi elementi Array dell'oggetto Array originale. Gli elementi stessi o qualsiasi elemento a cui fanno riferimento gli elementi non vengono copiati. Al contrario, una copia completa di un copia gli elementi e tutti gli elementi a cui gli elementi fanno riferimento direttamente o Array indirettamente.

Viene ArrayTypeMismatchException generata un'eccezione se le matrici sono di tipi incompatibili. La compatibilità dei tipi è definita nel modo seguente:

  • Un tipo è compatibile con se stesso.

  • Un tipo valore è compatibile con Object e con un tipo di interfaccia implementato da tale tipo di valore. Un tipo valore viene considerato connesso a un'interfaccia solo se implementa direttamente tale interfaccia. I tipi disconnessi non sono compatibili.

  • Due tipi valore intrinseci (predefiniti) sono compatibili se la copia dal tipo di origine al tipo di destinazione è una conversione più ampia. Una conversione più ampia non perde mai informazioni, mentre una conversione verso un tipo più ridotto 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 più ampia e la conversione di un intero con segno a 64 bit in un intero con segno a 32 bit è una conversione verso un tipo più piccolo. Per altre informazioni sulle conversioni, vedere Convert .

  • Un tipo di valore non unintrinsic (definito dall'utente) è compatibile solo con se stesso.

  • Le enumerazioni hanno una conversione Enum implicita in e nel tipo sottostante.

Se ogni elemento in richiede un downcast(ad esempio, da una classe di base a una classe derivata o da un'interfaccia a un oggetto) e non è possibile eseguire il cast di uno o più elementi al tipo corrispondente in , viene generata sourceArray destinationArray un'eccezione InvalidCastException .

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

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

Vedi anche

Si applica a

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.

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 MaxValue, inclusi.

Eccezioni

sourceArray è null.

-oppure-

destinationArray è null.

sourceArray e destinationArray hanno classificazioni diverse.

I tipi di sourceArray e destinationArray sono incompatibili.

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

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

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 devono avere lo stesso numero di destinationArray dimensioni. Inoltre, deve essere già stato dimensionato e deve avere un numero sufficiente di elementi a partire dalla posizione per destinationArray destinationIndex contenere i dati copiati.

Quando si esegue la copia tra matrici multidimensionali, la matrice si comporta come una lunga matrice unidimensionale, in cui le righe (o le colonne) sono concettualmente disposti end-to-end. Ad esempio, se una matrice ha tre righe (o colonne) con quattro elementi ciascuno, copiando sei elementi dall'inizio della matrice verranno copiati tutti e quattro gli elementi della prima riga (o colonna) e dei primi due elementi della seconda riga (o colonna). Per iniziare la copia dal secondo elemento della terza riga (o colonna), deve essere il limite superiore della prima riga (o colonna) più la lunghezza della seconda riga sourceIndex (o colonna) più due.

Se sourceArray e si sovrappongono, questo metodo si comporta come se i valori originali di fossero mantenuti in una posizione temporanea destinationArray prima della sourceArray destinationArray sovrascrittura.

[C++]

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

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 esegue la copia da una matrice di tipo riferimento a una matrice di tipo valore, ogni elemento viene unboxed e quindi copiato. Quando si copia da una matrice di tipo valore a una matrice di tipo riferimento, ogni elemento viene boxed e quindi copiato.

  • Quando si copia da una matrice reference-type o value-type a una matrice, viene creato un oggetto per contenere ogni valore o riferimento Object Object e quindi copiato. Quando si esegue la copia da una matrice a una matrice reference-type o value-type e l'assegnazione non è Object possibile, viene InvalidCastException generata un'eccezione .

  • Se e sono entrambe matrici di tipo riferimento o sono entrambe matrici di sourceArray tipo , viene eseguita una copia destinationArray Object superficiale. Una copia superficiale di Array un oggetto è un nuovo contenente riferimenti agli stessi elementi Array dell'oggetto Array originale. Gli elementi stessi o qualsiasi elemento a cui fanno riferimento gli elementi non vengono copiati. Al contrario, una copia completa di un copia gli elementi e tutti gli elementi a cui gli elementi fanno riferimento direttamente o Array indirettamente.

Viene ArrayTypeMismatchException generata un'eccezione se le matrici sono di tipi incompatibili. La compatibilità dei tipi è definita nel modo seguente:

  • Un tipo è compatibile con se stesso.

  • Un tipo valore è compatibile con Object e con un tipo di interfaccia implementato da tale tipo di valore. Un tipo valore viene considerato connesso a un'interfaccia solo se implementa direttamente tale interfaccia. I tipi disconnessi non sono compatibili.

  • Due tipi valore intrinseci (predefiniti) sono compatibili se la copia dal tipo di origine al tipo di destinazione è una conversione più ampia. Una conversione più ampia non perde mai le informazioni, mentre una conversione verso un tipo più ridotto 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 più ampia e la conversione di un intero con segno a 64 bit in un intero con segno a 32 bit è una conversione verso un tipo più piccolo. Per altre informazioni sulle conversioni, vedere Convert .

  • Un tipo di valore non unintrinsic (definito dall'utente) è compatibile solo con se stesso.

  • Le enumerazioni hanno una conversione Enum implicita in e nel tipo sottostante.

Se ogni elemento in richiede un downcast(ad esempio, da una classe di base a una classe derivata o da un'interfaccia a un oggetto) e non è possibile eseguire il cast di uno o più elementi al tipo corrispondente in , viene generata sourceArray destinationArray un'eccezione InvalidCastException .

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

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

Vedi anche

Si applica a