Array.Copy Metodo

Definizione

Spazio dei nomi:: System

Assembly:: netstandard.dll, System.Runtime.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Assembly:: mscorlib.dll, System.Runtime.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 uno all'altro Array Array ed esegue il cast dei tipi e la conversione boxing in base alle esigenze.

Overload

Nome	Descrizione
Copy(Array, Int64, Array, Int64, Int64)	Copia un intervallo di elementi da un Array oggetto a partire dall'indice di origine specificato e li incolla in un altro Array oggetto 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 Array oggetto a partire dall'indice di origine specificato e li incolla in un altro Array oggetto 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 Array oggetto a partire dal primo elemento e li incolla in un altro Array elemento 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 Array oggetto a partire dal primo elemento e li incolla in un altro Array elemento 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 Object a un altro Array di tipo integer.

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)

Origine:: Array.cs

Origine:: Array.cs

Origine:: Array.cs

Origine:: Array.cs

Origine:: Array.cs

Copia un intervallo di elementi da un Array oggetto a partire dall'indice di origine specificato e li incolla in un altro Array oggetto 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 contenente i dati da copiare.

sourceIndex: Int64

Intero a 64 bit che rappresenta l'indice in in sourceArray corrispondenza del quale inizia la copia.

destinationArray: Array

Oggetto Array che riceve i dati.

destinationIndex: Int64

Intero a 64 bit che rappresenta l'indice in in destinationArray corrispondenza del quale inizia 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, incluso.

Eccezioni

ArgumentNullException

sourceArray è null.

oppure

destinationArray è null.

RankException

sourceArray e destinationArray hanno ranghi diversi.

ArrayTypeMismatchException

sourceArray e destinationArray sono di tipi incompatibili.

InvalidCastException

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

ArgumentOutOfRangeException

sourceIndexnon è compreso nell'intervallo di indici validi per .sourceArray

oppure

destinationIndexnon è 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 da sourceIndex alla fine di sourceArray.

oppure

length è maggiore del numero di elementi da destinationIndex alla fine di destinationArray.

Commenti

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

Quando si copia 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 ha tre righe (o colonne) con quattro elementi ciascuno, la copia di sei elementi dall'inizio della matrice copia 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 sovrappongono, questo metodo si comporta come se i valori originali di sourceArray siano stati conservati in una posizione temporanea prima destinationArray di essere sovrascritti.

[C++]

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

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 deboxed e quindi copiato. Quando si copia da una matrice di tipo valore a una matrice di tipo riferimento, ogni elemento viene sottoposto a boxing 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 Object matrice a una matrice di tipo riferimento o di tipo valore e l'assegnazione non è possibile, viene generata un'eccezione InvalidCastException .
Se sourceArray e destinationArray sono entrambe matrici di tipo riferimento o entrambe 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'oggetto originale Array. Gli elementi stessi o qualsiasi elemento a cui fanno riferimento gli elementi non vengono copiati. Al contrario, una copia completa di un Array copia gli elementi e tutto direttamente o indirettamente a cui fanno riferimento gli elementi.

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

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 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 verso un tipo più esteso. Una conversione più ampia non perde mai informazioni, mentre una conversione verso un tipo di dati più piccolo 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 di tipo widening e la conversione di un intero con segno a 64 bit in un intero con segno a 32 bit è una conversione di tipo narrowing. Per altre informazioni sulle conversioni, vedere Convert.
Un tipo di valore nontrinsico (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 base a una classe derivata o da un'interfaccia a un oggetto) e uno o più elementi non possono essere cast al tipo corrispondente in destinationArray, viene generata un'eccezione InvalidCastException .

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)

Origine:: Array.cs

Origine:: Array.cs

Origine:: Array.CoreCLR.cs

Origine:: Array.cs

Origine:: 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 contenente i dati da copiare.

sourceIndex: Int32

Intero a 32 bit che rappresenta l'indice in in sourceArray corrispondenza del quale inizia la copia.

destinationArray: Array

Oggetto Array che riceve i dati.

destinationIndex: Int32

Intero a 32 bit che rappresenta l'indice in in destinationArray corrispondenza del quale inizia l'archiviazione.

length: Int32

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

Eccezioni

ArgumentNullException

sourceArray è null.

oppure

destinationArray è null.

RankException

sourceArray e destinationArray hanno ranghi diversi.

ArrayTypeMismatchException

sourceArray e destinationArray sono di tipi 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 da sourceIndex alla fine di sourceArray.

oppure

length è maggiore del numero di elementi da destinationIndex alla fine di destinationArray.

Commenti

[C++]

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

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 deboxed e quindi copiato. Quando si copia da una matrice di tipo valore a una matrice di tipo riferimento, ogni elemento viene sottoposto a boxing 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 Object matrice a una matrice di tipo riferimento o di tipo valore e l'assegnazione non è possibile, viene generata un'eccezione InvalidCastException .
Se sourceArray e destinationArray sono entrambe matrici di tipo riferimento o entrambe 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'oggetto originale Array. Gli elementi stessi o qualsiasi elemento a cui fanno riferimento gli elementi non vengono copiati. Al contrario, una copia completa di un Array copia gli elementi e tutto direttamente o indirettamente a cui fanno riferimento gli elementi.

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

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 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 verso un tipo più esteso. Una conversione più ampia non perde mai informazioni, mentre una conversione verso un tipo di dati più piccolo 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 di tipo widening e la conversione di un intero con segno a 64 bit in un intero con segno a 32 bit è una conversione di tipo narrowing. Per altre informazioni sulle conversioni, vedere Convert.
Un tipo di valore nontrinsico (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)

Origine:: Array.cs

Origine:: Array.cs

Origine:: Array.CoreCLR.cs

Origine:: Array.cs

Origine:: Array.cs

Copia un intervallo di elementi da un Array oggetto a partire dal primo elemento e li incolla in un altro Array elemento 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 contenente i dati da copiare.

destinationArray: Array

Oggetto Array che riceve i dati.

length: Int32

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

Eccezioni

ArgumentNullException

sourceArray è null.

oppure

destinationArray è null.

RankException

sourceArray e destinationArray hanno ranghi diversi.

ArrayTypeMismatchException

sourceArray e destinationArray sono di tipi 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

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 per contenere i dati copiati.

[C++]

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

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 deboxed e quindi copiato. Quando si copia da una matrice di tipo valore a una matrice di tipo riferimento, ogni elemento viene sottoposto a boxing 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 Object matrice a una matrice di tipo riferimento o di tipo valore e l'assegnazione non è possibile, viene generata un'eccezione InvalidCastException .
Se sourceArray e destinationArray sono entrambe matrici di tipo riferimento o entrambe 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'oggetto originale Array. Gli elementi stessi o qualsiasi elemento a cui fanno riferimento gli elementi non vengono copiati. Al contrario, una copia completa di un Array copia gli elementi e tutto direttamente o indirettamente a cui fanno riferimento gli elementi.

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

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 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 verso un tipo più esteso. Una conversione più ampia non perde mai informazioni, mentre una conversione verso un tipo di dati più piccolo 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 di tipo widening e la conversione di un intero con segno a 64 bit in un intero con segno a 32 bit è una conversione di tipo narrowing. Per altre informazioni sulle conversioni, vedere Convert.
Un tipo di valore nontrinsico (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)

Origine:: Array.cs

Origine:: Array.cs

Origine:: Array.cs

Origine:: Array.cs

Origine:: 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 contenente 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, incluso.

Eccezioni

ArgumentNullException

sourceArray è null.

oppure

destinationArray è null.

RankException

sourceArray e destinationArray hanno ranghi diversi.

ArrayTypeMismatchException

sourceArray e destinationArray sono di tipi 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 memcpya .

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 deboxed e quindi copiato. Quando si copia da una matrice di tipo valore a una matrice di tipo riferimento, ogni elemento viene sottoposto a boxing 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 Object matrice a una matrice di tipo riferimento o di tipo valore e l'assegnazione non è possibile, viene generata un'eccezione InvalidCastException .
Se sourceArray e destinationArray sono entrambe matrici di tipo riferimento o entrambe 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'oggetto originale Array. Gli elementi stessi o qualsiasi elemento a cui fanno riferimento gli elementi non vengono copiati. Al contrario, una copia completa di un Array copia gli elementi e tutto direttamente o indirettamente a cui fanno riferimento gli elementi.

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

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 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 verso un tipo più esteso. Una conversione più ampia non perde mai informazioni, mentre una conversione verso un tipo di dati più piccolo 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 di tipo widening e la conversione di un intero con segno a 64 bit in un intero con segno a 32 bit è una conversione di tipo narrowing. Per altre informazioni sulle conversioni, vedere Convert.
Un tipo di valore nontrinsico (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

Commenti e suggerimenti

Questa pagina è stata utile?