Teilen über

Array.Copy Methode

  • Referenz

Definition

Namespace:
System
Assembly:
System.Runtime.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Kopiert einen Bereich von Elementen eines Array in ein anderes Array und führt ggf. Typumwandlungen und Boxing durch.

Überlädt

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

Kopiert einen beim angegebenen Quellindex beginnenden Elementbereich aus einem Array und fügt ihn ab dem angegebenen Zielindex in ein anderes Array ein. Die Länge und die Indizes werden als 64-Bit-Ganzzahlen angegeben.
Copy(Array, Int32, Array, Int32, Int32)

Kopiert einen beim angegebenen Quellindex beginnenden Elementbereich aus einem Array und fügt ihn ab dem angegebenen Zielindex in ein anderes Array ein. Die Länge und die Indizes werden als 32-Bit-Ganzzahlen angegeben.
Copy(Array, Array, Int32)

Kopiert einen mit dem ersten Element beginnenden Elementbereich eines Array und fügt ihn ab dem ersten Element in ein anderes Array ein. Die Länge wird als 32-Bit-Ganzzahl angegeben.
Copy(Array, Array, Int64)

Kopiert einen mit dem ersten Element beginnenden Elementbereich eines Array und fügt ihn ab dem ersten Element in ein anderes Array ein. Die Länge wird als 64-Bit-Ganzzahl angegeben.

Beispiele

Im folgenden Codebeispiel wird gezeigt, wie sie von einem Typ Object in eine Array andere Array vom Typ integer kopiert werden.

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)

Quelle:
Array.cs
Quelle:
Array.cs
Quelle:
Array.cs

Kopiert einen beim angegebenen Quellindex beginnenden Elementbereich aus einem Array und fügt ihn ab dem angegebenen Zielindex in ein anderes Array ein. Die Länge und die Indizes werden als 64-Bit-Ganzzahlen angegeben.

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)

Parameter

sourceArray
Array

Das Array, das die zu kopierenden Daten enthält.

sourceIndex
Int64

Eine 64-Bit-Ganzzahl, die den Index im sourceArray angibt, ab dem kopiert werden soll.

destinationArray
Array

Das Array, das die Daten empfängt.

destinationIndex
Int64

Eine 64-Bit-Ganzzahl, die den Index im destinationArray angibt, ab dem gespeichert werden soll.

length
Int64

Eine 64-Bit-Ganzzahl, die die Anzahl der zu kopierenden Elemente darstellt. Die ganze Zahl muss zwischen 0 (null) und Int32.MaxValue (einschließlich) liegen.

Ausnahmen

ArgumentNullException

sourceArray ist null.

- oder -

destinationArray ist null.

RankException

sourceArray und destinationArray sind von unterschiedlichem Rang.

ArrayTypeMismatchException

sourceArray und destinationArray weisen inkompatible Typen auf.

InvalidCastException

Mindestens ein Element in sourceArray kann nicht in den destinationArray-Typ umgewandelt werden.

ArgumentOutOfRangeException

sourceIndex liegt außerhalb des Bereichs der gültigen Indizes für das sourceArray.

- oder -

destinationIndex liegt außerhalb des Bereichs der gültigen Indizes für das destinationArray.

- oder -

length ist kleiner als 0 oder größer als Int32.MaxValue.

ArgumentException

length ist größer als die Anzahl der Elemente vom sourceIndex bis zum Ende des sourceArrays.

- oder -

length ist größer als die Anzahl der Elemente vom destinationIndex bis zum Ende des destinationArrays.

Hinweise

Die sourceArray Parameter und destinationArray müssen dieselbe Anzahl von Dimensionen aufweisen. Darüber hinaus muss bereits dimensioniert sein und über eine ausreichende Anzahl von Elementen verfügen, destinationArray beginnend mit der destinationIndex Position, um die kopierten Daten aufzunehmen.

Beim Kopieren zwischen mehrdimensionalen Arrays verhält sich das Array wie ein langes eindimensionales Array, bei dem die Zeilen (oder Spalten) konzeptionell end-to-end angeordnet werden. Wenn ein Array beispielsweise über drei Zeilen (oder Spalten) mit jeweils vier Elementen verfügt, würde das Kopieren von sechs Elementen vom Anfang des Arrays alle vier Elemente der ersten Zeile (oder Spalte) und der ersten beiden Elemente der zweiten Zeile (oder Spalte) kopieren. Um mit dem Kopieren aus dem zweiten Element der dritten Zeile (oder Spalte) zu beginnen, sourceIndex muss die obere Grenze der ersten Zeile (oder Spalte) plus der Länge der zweiten Zeile (oder Spalte) plus zwei sein.

Wenn sourceArray und destinationArray überlappen, verhält sich diese Methode so, als ob die ursprünglichen Werte von sourceArray an einem temporären Speicherort beibehalten wurden, bevor destinationArray überschrieben wird.

[C++]

Diese Methode entspricht der C/C++-Standardfunktion memmove, nicht memcpy.

Die Arrays können Verweistyparrays oder Werttyparrays sein. Das Typdowncasting wird nach Bedarf ausgeführt.

  • Beim Kopieren von einem Verweistyparray in ein Werttyparray wird jedes Element ausgepackt und dann kopiert. Beim Kopieren von einem Werttyparray in ein Verweistyparray wird jedes Element geschachtelt und dann kopiert.

  • Beim Kopieren von einem Verweistyp- oder Werttyparray in ein Object Array wird ein Object erstellt, um jeden Wert oder Verweis zu enthalten, und dann kopiert. Beim Kopieren von einem Object Array in ein Verweistyp- oder Werttyparray und die Zuweisung ist nicht möglich, wird eine InvalidCastException ausgelöst.

  • Wenn sourceArray und destinationArray beide Verweistyparrays sind oder beide Arrays vom Typ Objectsind, wird eine flache Kopie ausgeführt. Eine flache Kopie eines Array ist eine neue Array , die Verweise auf die gleichen Elemente wie die ursprüngliche Arrayenthält. Die Elemente selbst oder alle elemente, auf die von den Elementen verwiesen wird, werden nicht kopiert. Im Gegensatz dazu kopiert eine tiefe Kopie eines Array die Elemente und alles, auf das direkt oder indirekt von den Elementen verwiesen wird.

Ein ArrayTypeMismatchException wird ausgelöst, wenn die Arrays inkompatible Typen aufweisen. Die Typkompatibilität ist wie folgt definiert:

  • Ein Typ ist mit sich selbst kompatibel.

  • Ein Werttyp ist mit Object und mit einem Schnittstellentyp kompatibel, der von diesem Werttyp implementiert wird. Ein Werttyp gilt nur dann als mit einer Schnittstelle verbunden, wenn er diese Schnittstelle direkt implementiert. Getrennte Typen sind nicht kompatibel.

  • Zwei systeminterne (vordefinierte) Werttypen sind kompatibel, wenn das Kopieren vom Quelltyp in den Zieltyp eine erweiterungsfähige Konvertierung ist. Bei einer Erweiterungskonvertierung gehen nie Informationen verloren, während bei einer einschränkenden Konvertierung Informationen verloren gehen können. Beispielsweise ist das Konvertieren einer 32-Bit-Ganzzahl mit Vorzeichen in eine 64-Bit-Ganzzahl mit Vorzeichen eine Erweiterungskonvertierung, und das Konvertieren einer 64-Bit-Ganzzahl mit Vorzeichen in eine 32-Bit-Ganzzahl mit Vorzeichen ist eine einschränkende Konvertierung. Weitere Informationen zu Konvertierungen finden Sie unter Convert.

  • Ein nichtintrinsischer (benutzerdefinierter) Werttyp ist nur mit sich selbst kompatibel.

  • Enumerationen verfügen über eine implizite Konvertierung in Enum und in den zugrunde liegenden Typ.

Wenn für jedes Element in sourceArray ein Downcast erforderlich ist (z. B. von einer Basisklasse zu einer abgeleiteten Klasse oder von einer Schnittstelle zu einem Objekt), und ein oder mehrere Elemente nicht in den entsprechenden Typ in destinationArrayumgewandelt werden können, wird eine InvalidCastException ausgelöst.

Wenn diese Methode beim Kopieren eine Ausnahme auslöst, ist der Zustand von destinationArray nicht definiert.

Bei dieser Methode handelt es sich um einen O(n)-Vorgang, wobei n ist length.

Weitere Informationen

Gilt für:

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

Quelle:
Array.CoreCLR.cs
Quelle:
Array.cs
Quelle:
Array.cs

Kopiert einen beim angegebenen Quellindex beginnenden Elementbereich aus einem Array und fügt ihn ab dem angegebenen Zielindex in ein anderes Array ein. Die Länge und die Indizes werden als 32-Bit-Ganzzahlen angegeben.

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)

Parameter

sourceArray
Array

Das Array, das die zu kopierenden Daten enthält.

sourceIndex
Int32

Eine 32-Bit-Ganzzahl, die den Index im sourceArray angibt, ab dem kopiert werden soll.

destinationArray
Array

Das Array, das die Daten empfängt.

destinationIndex
Int32

Eine 32-Bit-Ganzzahl, die den Index im destinationArray angibt, ab dem gespeichert werden soll.

length
Int32

Eine 32-Bit-Ganzzahl, die die Anzahl der zu kopierenden Elemente darstellt.

Ausnahmen

ArgumentNullException

sourceArray ist null.

- oder -

destinationArray ist null.

RankException

sourceArray und destinationArray sind von unterschiedlichem Rang.

ArrayTypeMismatchException

sourceArray und destinationArray weisen inkompatible Typen auf.

InvalidCastException

Mindestens ein Element in sourceArray kann nicht in den destinationArray-Typ umgewandelt werden.

ArgumentOutOfRangeException

sourceIndex ist kleiner als die untere Grenze der ersten Dimension von sourceArray.

- oder -

destinationIndex ist kleiner als die untere Grenze der ersten Dimension von destinationArray.

- oder -

length ist kleiner als Null.

ArgumentException

length ist größer als die Anzahl der Elemente vom sourceIndex bis zum Ende des sourceArrays.

- oder -

length ist größer als die Anzahl der Elemente vom destinationIndex bis zum Ende des destinationArrays.

Hinweise

Die sourceArray Parameter und destinationArray müssen dieselbe Anzahl von Dimensionen aufweisen. Darüber hinaus muss bereits dimensioniert sein und über eine ausreichende Anzahl von Elementen verfügen, destinationArray beginnend mit der destinationIndex Position, um die kopierten Daten aufzunehmen.

Beim Kopieren zwischen mehrdimensionalen Arrays verhält sich das Array wie ein langes eindimensionales Array, bei dem die Zeilen (oder Spalten) konzeptionell end-to-end angeordnet werden. Wenn ein Array beispielsweise über drei Zeilen (oder Spalten) mit jeweils vier Elementen verfügt, würde das Kopieren von sechs Elementen vom Anfang des Arrays alle vier Elemente der ersten Zeile (oder Spalte) und der ersten beiden Elemente der zweiten Zeile (oder Spalte) kopieren. Um mit dem Kopieren aus dem zweiten Element der dritten Zeile (oder Spalte) zu beginnen, sourceIndex muss die obere Grenze der ersten Zeile (oder Spalte) plus der Länge der zweiten Zeile (oder Spalte) plus zwei sein.

Wenn sourceArray und destinationArray überlappen, verhält sich diese Methode so, als ob die ursprünglichen Werte von sourceArray an einem temporären Speicherort beibehalten wurden, bevor destinationArray überschrieben wird.

[C++]

Diese Methode entspricht der C/C++-Standardfunktion memmove, nicht memcpy.

Die Arrays können Verweistyparrays oder Werttyparrays sein. Die Typabwandlung wird nach Bedarf ausgeführt.

  • Beim Kopieren von einem Verweistyparray in ein Werttyparray wird jedes Element entpackt und dann kopiert. Beim Kopieren von einem Werttyparray in ein Verweistyparray wird jedes Element schachtelt und dann kopiert.

  • Beim Kopieren von einem Verweistyp- oder Werttyparray in ein Object Array wird ein Object erstellt, um jeden Wert oder Verweis zu enthalten, und dann kopiert. Beim Kopieren von einem Object Array in ein Verweistyp- oder Werttyparray und die Zuweisung ist nicht möglich, wird ein InvalidCastException ausgelöst.

  • Wenn sourceArray und destinationArray beide Verweistyparrays sind oder beide Arrays vom Typ Objectsind, wird eine flache Kopie ausgeführt. Eine flache Kopie eines Array ist eine neue Array , die Verweise auf die gleichen Elemente wie das ursprüngliche Arrayenthält. Die Elemente selbst oder alles, auf das von den Elementen verwiesen wird, werden nicht kopiert. Im Gegensatz dazu kopiert eine tiefgehende Kopie eines Array die Elemente und alles, auf das direkt oder indirekt von den Elementen verwiesen wird.

Ein ArrayTypeMismatchException wird ausgelöst, wenn die Arrays inkompatible Typen aufweisen. Die Typkompatibilität wird wie folgt definiert:

  • Ein Typ ist mit sich selbst kompatibel.

  • Ein Werttyp ist mit Object und mit einem Schnittstellentyp kompatibel, der von diesem Werttyp implementiert wird. Ein Werttyp gilt nur dann als mit einer Schnittstelle verbunden, wenn er diese Schnittstelle direkt implementiert. Getrennte Typen sind nicht kompatibel.

  • Zwei intrinsische (vordefinierte) Werttypen sind kompatibel, wenn das Kopieren vom Quelltyp in den Zieltyp eine erweiterungsfähige Konvertierung ist. Bei einer erweiterten Konvertierung gehen nie Informationen verloren, während bei einer einschränkenden Konvertierung Informationen verloren gehen können. Beispielsweise ist das Konvertieren einer 32-Bit-Ganzzahl mit Vorzeichen in eine 64-Bit-Ganzzahl mit Vorzeichen eine erweiterungsfähige Konvertierung, und das Konvertieren einer 64-Bit-Ganzzahl mit Vorzeichen in eine 32-Bit-Ganzzahl mit Vorzeichen ist eine einschränkende Konvertierung. Weitere Informationen zu Konvertierungen finden Sie unter Convert.

  • Ein nichtintrinsischer (benutzerdefinierter) Werttyp ist nur mit sich selbst kompatibel.

  • Enumerationen verfügen über eine implizite Konvertierung in Enum und in den zugrunde liegenden Typ.

Wenn für jedes Element in sourceArray ein Downcast erforderlich ist (z. B. von einer Basisklasse auf eine abgeleitete Klasse oder von einer Schnittstelle zu einem Objekt), und ein oder mehrere Elemente nicht in den entsprechenden Typ in destinationArrayumgewandelt werden können, wird ein InvalidCastException ausgelöst.

Wenn diese Methode beim Kopieren eine Ausnahme auslöst, ist der Zustand von destinationArray nicht definiert.

Diese Methode ist ein O()n-Vorgang, wobei n ist length.

Weitere Informationen

Gilt für:

Copy(Array, Array, Int32)

Quelle:
Array.CoreCLR.cs
Quelle:
Array.cs
Quelle:
Array.cs

Kopiert einen mit dem ersten Element beginnenden Elementbereich eines Array und fügt ihn ab dem ersten Element in ein anderes Array ein. Die Länge wird als 32-Bit-Ganzzahl angegeben.

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)

Parameter

sourceArray
Array

Das Array, das die zu kopierenden Daten enthält.

destinationArray
Array

Das Array, das die Daten empfängt.

length
Int32

Eine 32-Bit-Ganzzahl, die die Anzahl der zu kopierenden Elemente darstellt.

Ausnahmen

ArgumentNullException

sourceArray ist null.

- oder -

destinationArray ist null.

RankException

sourceArray und destinationArray sind von unterschiedlichem Rang.

ArrayTypeMismatchException

sourceArray und destinationArray weisen inkompatible Typen auf.

InvalidCastException

Mindestens ein Element in sourceArray kann nicht in den destinationArray-Typ umgewandelt werden.

ArgumentOutOfRangeException

length ist kleiner als Null.

ArgumentException

length ist größer als die Anzahl von Elementen in sourceArray.

- oder -

length ist größer als die Anzahl von Elementen in destinationArray.

Hinweise

Die sourceArray Parameter und destinationArray müssen die gleiche Anzahl von Dimensionen aufweisen. Darüber hinaus destinationArray muss bereits dimensioniert worden sein und eine ausreichende Anzahl von Elementen enthalten, um die kopierten Daten aufzunehmen.

Beim Kopieren zwischen mehrdimensionalen Arrays verhält sich das Array wie ein langes eindimensionales Array, bei dem die Zeilen (oder Spalten) konzeptionell End to End angeordnet werden. Wenn ein Array beispielsweise über drei Zeilen (oder Spalten) mit jeweils vier Elementen verfügt, würde das Kopieren von sechs Elementen vom Anfang des Arrays alle vier Elemente der ersten Zeile (oder Spalte) und die ersten beiden Elemente der zweiten Zeile (oder Spalte) kopieren.

Wenn sourceArray und destinationArray überlappen, verhält sich diese Methode so, als ob die ursprünglichen Werte von sourceArray an einem temporären Speicherort beibehalten wurden, bevor destinationArray überschrieben wird.

[C++]

Diese Methode entspricht der C/C++-Standardfunktion memmove, nicht memcpy.

Die Arrays können Verweistyparrays oder Werttyparrays sein. Die Typabwandlung wird nach Bedarf ausgeführt.

  • Beim Kopieren von einem Verweistyparray in ein Werttyparray wird jedes Element entpackt und dann kopiert. Beim Kopieren von einem Werttyparray in ein Verweistyparray wird jedes Element schachtelt und dann kopiert.

  • Beim Kopieren von einem Verweistyp- oder Werttyparray in ein Object Array wird ein Object erstellt, um jeden Wert oder Verweis zu enthalten, und dann kopiert. Beim Kopieren von einem Object Array in ein Verweistyp- oder Werttyparray und die Zuweisung ist nicht möglich, wird ein InvalidCastException ausgelöst.

  • Wenn sourceArray und destinationArray beide Verweistyparrays sind oder beide Arrays vom Typ Objectsind, wird eine flache Kopie ausgeführt. Eine flache Kopie eines Array ist eine neue Array , die Verweise auf die gleichen Elemente wie das ursprüngliche Arrayenthält. Die Elemente selbst oder alles, auf das von den Elementen verwiesen wird, werden nicht kopiert. Im Gegensatz dazu kopiert eine tiefgehende Kopie eines Array die Elemente und alles, auf das direkt oder indirekt von den Elementen verwiesen wird.

Ein ArrayTypeMismatchException wird ausgelöst, wenn die Arrays inkompatible Typen aufweisen. Die Typkompatibilität wird wie folgt definiert:

  • Ein Typ ist mit sich selbst kompatibel.

  • Ein Werttyp ist mit Object und mit einem Schnittstellentyp kompatibel, der von diesem Werttyp implementiert wird. Ein Werttyp gilt nur dann als mit einer Schnittstelle verbunden, wenn er diese Schnittstelle direkt implementiert. Getrennte Typen sind nicht kompatibel.

  • Zwei intrinsische (vordefinierte) Werttypen sind kompatibel, wenn das Kopieren vom Quelltyp in den Zieltyp eine erweiterungsfähige Konvertierung ist. Bei einer erweiterten Konvertierung gehen nie Informationen verloren, während bei einer einschränkenden Konvertierung Informationen verloren gehen können. Beispielsweise ist das Konvertieren einer 32-Bit-Ganzzahl mit Vorzeichen in eine 64-Bit-Ganzzahl mit Vorzeichen eine erweiterungsfähige Konvertierung, und das Konvertieren einer 64-Bit-Ganzzahl mit Vorzeichen in eine 32-Bit-Ganzzahl mit Vorzeichen ist eine einschränkende Konvertierung. Weitere Informationen zu Konvertierungen finden Sie unter Convert.

  • Ein nichtintrinsischer (benutzerdefinierter) Werttyp ist nur mit sich selbst kompatibel.

  • Enumerationen verfügen über eine implizite Konvertierung in Enum und in den zugrunde liegenden Typ.

Wenn für jedes Element in sourceArray ein Downcast erforderlich ist (z. B. von einer Basisklasse auf eine abgeleitete Klasse oder von einer Schnittstelle zu einem Objekt), und ein oder mehrere Elemente nicht in den entsprechenden Typ in destinationArrayumgewandelt werden können, wird ein InvalidCastException ausgelöst.

Wenn diese Methode beim Kopieren eine Ausnahme auslöst, ist der Zustand von destinationArray nicht definiert.

Diese Methode ist ein O()n-Vorgang, wobei n ist length.

Weitere Informationen

Gilt für:

Copy(Array, Array, Int64)

Quelle:
Array.cs
Quelle:
Array.cs
Quelle:
Array.cs

Kopiert einen mit dem ersten Element beginnenden Elementbereich eines Array und fügt ihn ab dem ersten Element in ein anderes Array ein. Die Länge wird als 64-Bit-Ganzzahl angegeben.

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)

Parameter

sourceArray
Array

Das Array, das die zu kopierenden Daten enthält.

destinationArray
Array

Das Array, das die Daten empfängt.

length
Int64

Eine 64-Bit-Ganzzahl, die die Anzahl der zu kopierenden Elemente darstellt. Die ganze Zahl muss zwischen null und Int32.MaxValue liegen, einschließlich.

Ausnahmen

ArgumentNullException

sourceArray ist null.

- oder -

destinationArray ist null.

RankException

sourceArray und destinationArray sind von unterschiedlichem Rang.

ArrayTypeMismatchException

sourceArray und destinationArray weisen inkompatible Typen auf.

InvalidCastException

Mindestens ein Element in sourceArray kann nicht in den destinationArray-Typ umgewandelt werden.

ArgumentOutOfRangeException

length ist kleiner als 0 oder größer als Int32.MaxValue.

ArgumentException

length ist größer als die Anzahl von Elementen in sourceArray.

- oder -

length ist größer als die Anzahl von Elementen in destinationArray.

Hinweise

Die sourceArray Parameter und destinationArray müssen die gleiche Anzahl von Dimensionen aufweisen. Darüber hinaus destinationArray muss bereits dimensioniert worden sein und eine ausreichende Anzahl von Elementen enthalten, um die kopierten Daten aufzunehmen.

Beim Kopieren zwischen mehrdimensionalen Arrays verhält sich das Array wie ein langes eindimensionales Array, bei dem die Zeilen (oder Spalten) konzeptionell End to End angeordnet werden. Wenn ein Array beispielsweise über drei Zeilen (oder Spalten) mit jeweils vier Elementen verfügt, würde das Kopieren von sechs Elementen vom Anfang des Arrays alle vier Elemente der ersten Zeile (oder Spalte) und die ersten beiden Elemente der zweiten Zeile (oder Spalte) kopieren.

Wenn sourceArray und destinationArray überlappen, verhält sich diese Methode so, als ob die ursprünglichen Werte von sourceArray an einem temporären Speicherort beibehalten wurden, bevor destinationArray überschrieben wird.

[C++]

Diese Methode entspricht der C/C++-Standardfunktion memmove, nicht memcpy.

Die Arrays können Verweistyparrays oder Werttyparrays sein. Die Typabwandlung wird nach Bedarf ausgeführt.

  • Beim Kopieren von einem Verweistyparray in ein Werttyparray wird jedes Element entpackt und dann kopiert. Beim Kopieren von einem Werttyparray in ein Verweistyparray wird jedes Element schachtelt und dann kopiert.

  • Beim Kopieren von einem Verweistyp- oder Werttyparray in ein Object Array wird ein Object erstellt, um jeden Wert oder Verweis zu enthalten, und dann kopiert. Beim Kopieren von einem Object Array in ein Verweistyp- oder Werttyparray und die Zuweisung ist nicht möglich, wird ein InvalidCastException ausgelöst.

  • Wenn sourceArray und destinationArray beide Verweistyparrays sind oder beide Arrays vom Typ Objectsind, wird eine flache Kopie ausgeführt. Eine flache Kopie eines Array ist eine neue Array , die Verweise auf die gleichen Elemente wie das ursprüngliche Arrayenthält. Die Elemente selbst oder alles, auf das von den Elementen verwiesen wird, werden nicht kopiert. Im Gegensatz dazu kopiert eine tiefgehende Kopie eines Array die Elemente und alles, auf das direkt oder indirekt von den Elementen verwiesen wird.

Ein ArrayTypeMismatchException wird ausgelöst, wenn die Arrays inkompatible Typen aufweisen. Die Typkompatibilität wird wie folgt definiert:

  • Ein Typ ist mit sich selbst kompatibel.

  • Ein Werttyp ist mit Object und mit einem Schnittstellentyp kompatibel, der von diesem Werttyp implementiert wird. Ein Werttyp gilt nur dann als mit einer Schnittstelle verbunden, wenn er diese Schnittstelle direkt implementiert. Getrennte Typen sind nicht kompatibel.

  • Zwei intrinsische (vordefinierte) Werttypen sind kompatibel, wenn das Kopieren vom Quelltyp in den Zieltyp eine erweiterungsfähige Konvertierung ist. Bei einer erweiterten Konvertierung gehen nie Informationen verloren, während bei einer einschränkenden Konvertierung Informationen verloren gehen können. Beispielsweise ist das Konvertieren einer 32-Bit-Ganzzahl mit Vorzeichen in eine 64-Bit-Ganzzahl mit Vorzeichen eine erweiterungsfähige Konvertierung, und das Konvertieren einer 64-Bit-Ganzzahl mit Vorzeichen in eine 32-Bit-Ganzzahl mit Vorzeichen ist eine einschränkende Konvertierung. Weitere Informationen zu Konvertierungen finden Sie unter Convert.

  • Ein nichtintrinsischer (benutzerdefinierter) Werttyp ist nur mit sich selbst kompatibel.

  • Enumerationen verfügen über eine implizite Konvertierung in Enum und in den zugrunde liegenden Typ.

Wenn für jedes Element in sourceArray ein Downcast erforderlich ist (z. B. von einer Basisklasse auf eine abgeleitete Klasse oder von einer Schnittstelle zu einem Objekt), und ein oder mehrere Elemente nicht in den entsprechenden Typ in destinationArrayumgewandelt werden können, wird ein InvalidCastException ausgelöst.

Wenn diese Methode beim Kopieren eine Ausnahme auslöst, ist der Zustand von destinationArray nicht definiert.

Diese Methode ist ein O()n-Vorgang, wobei n ist length.

Weitere Informationen

Gilt für: