Array.CopyTo Methode

Referenz

Definition

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Kopiert alle Elemente des aktuellen eindimensionalen Arrays in das angegebene eindimensionale Array.

Überlädt

CopyTo(Array, Int32)	Kopiert alle Elemente des aktuellen eindimensionalen Arrays in das angegebene eindimensionale Array, beginnend am angegebenen Index des Zielarrays. Der Index wird als 32-Bit-Ganzzahl angegeben.
CopyTo(Array, Int64)	Kopiert alle Elemente des aktuellen eindimensionalen Arrays in das angegebene eindimensionale Array, beginnend am angegebenen Index des Zielarrays. Der Index wird als 64-Bit-Ganzzahl angegeben.

Beispiele

Das folgende Codebeispiel zeigt, wie ein in ein Array anderes Arraykopiert wird.

using namespace System;

void main()
{
   // Creates and initializes two new Array instances.
   Array^ mySourceArray = Array::CreateInstance(String::typeid, 6);
   mySourceArray->SetValue("three", 0);
   mySourceArray->SetValue("napping", 1);
   mySourceArray->SetValue("cats", 2);
   mySourceArray->SetValue("in", 3);
   mySourceArray->SetValue("the", 4);
   mySourceArray->SetValue("barn", 5);
   Array^ myTargetArray = Array::CreateInstance(String::typeid, 15);
   myTargetArray->SetValue("The", 0);
   myTargetArray->SetValue("quick", 1);
   myTargetArray->SetValue("brown", 2);
   myTargetArray->SetValue("fox", 3);
   myTargetArray->SetValue("jumps", 4);
   myTargetArray->SetValue("over", 5);
   myTargetArray->SetValue("the", 6);
   myTargetArray->SetValue("lazy", 7);
   myTargetArray->SetValue("dog", 8);

   // Displays the values of the Array.
   Console::WriteLine( "The target Array instance contains the following (before and after copying):");
   PrintValues(myTargetArray);

   // Copies the source Array to the target Array, starting at index 6.
   mySourceArray->CopyTo(myTargetArray, 6);

   // Displays the values of the Array.
   PrintValues(myTargetArray);
}

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( " {0}", myEnumerator->Current);
   }

   Console::WriteLine();
}

/*
 This code produces the following output.
 
  The target Array instance contains the following (before and after copying):
  The quick brown fox jumps over the lazy dog      
  The quick brown fox jumps over three napping cats in the barn
 */

let printValues arr sep =
    for i in arr do
        printf $"{sep}{i}"
    printfn ""

// Creates and initializes two new Arrays.
let mySourceArray = 
    [| "three"
       "napping"
       "cats"
       "in"
       "the"
       "barn" |]

let myTargetArray = Array.zeroCreate 15
myTargetArray[0..8] <-
    [| "The"
       "quick"
       "brown"
       "fox"
       "jumps"
       "over"
       "the"
       "lazy"
       "dog" |]

// Displays the values of the Array.
printfn "The target Array contains the following (before and after copying):"
printValues myTargetArray ' '

// Copies the source Array to the target Array, starting at index 6.
mySourceArray.CopyTo(myTargetArray, 6)

// Displays the values of the Array.
printValues myTargetArray ' '


// This code produces the following output.
//     The target Array contains the following (before and after copying):
//      The quick brown fox jumps over the lazy dog
//      The quick brown fox jumps over three napping cats in the barn

using System;

public class SamplesArray
{

   public static void Main()
   {

      // Creates and initializes two new Arrays.
      Array mySourceArray=Array.CreateInstance(typeof(string), 6);
      mySourceArray.SetValue("three", 0);
      mySourceArray.SetValue("napping", 1);
      mySourceArray.SetValue("cats", 2);
      mySourceArray.SetValue("in", 3);
      mySourceArray.SetValue("the", 4);
      mySourceArray.SetValue("barn", 5);
      Array myTargetArray=Array.CreateInstance(typeof(string), 15);
      myTargetArray.SetValue("The", 0);
      myTargetArray.SetValue("quick", 1);
      myTargetArray.SetValue("brown", 2);
      myTargetArray.SetValue("fox", 3);
      myTargetArray.SetValue("jumps", 4);
      myTargetArray.SetValue("over", 5);
      myTargetArray.SetValue("the", 6);
      myTargetArray.SetValue("lazy", 7);
      myTargetArray.SetValue("dog", 8);

      // Displays the values of the Array.
      Console.WriteLine("The target Array contains the following (before and after copying):");
      PrintValues(myTargetArray, ' ');

      // Copies the source Array to the target Array, starting at index 6.
      mySourceArray.CopyTo(myTargetArray, 6);

      // Displays the values of the Array.
      PrintValues(myTargetArray, ' ');
   }

   public static void PrintValues(Array myArr, char mySeparator)
   {

      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("{0}{1}", mySeparator, myEnumerator.Current);
      }
      Console.WriteLine();
   }
}
/*
This code produces the following output.

The target Array contains the following (before and after copying):
 The quick brown fox jumps over the lazy dog
 The quick brown fox jumps over three napping cats in the barn
*/

Public Class SamplesArray    
    
    Public Shared Sub Main()
        
        ' Creates and initializes two new Arrays.
        Dim mySourceArray As Array = Array.CreateInstance(GetType(String), 6)
        mySourceArray.SetValue("three", 0)
        mySourceArray.SetValue("napping", 1)
        mySourceArray.SetValue("cats", 2)
        mySourceArray.SetValue("in", 3)
        mySourceArray.SetValue("the", 4)
        mySourceArray.SetValue("barn", 5)
        Dim myTargetArray As Array = Array.CreateInstance(GetType(String), 15)
        myTargetArray.SetValue("The", 0)
        myTargetArray.SetValue("quick", 1)
        myTargetArray.SetValue("brown", 2)
        myTargetArray.SetValue("fox", 3)
        myTargetArray.SetValue("jumps", 4)
        myTargetArray.SetValue("over", 5)
        myTargetArray.SetValue("the", 6)
        myTargetArray.SetValue("lazy", 7)
        myTargetArray.SetValue("dog", 8)
        
        ' Displays the values of the Array.
        Console.WriteLine("The target Array contains the following" _
           & "(before and after copying):")
        PrintValues(myTargetArray, " "c)
        
        ' Copies the source Array to the target Array, starting at index 6.
        mySourceArray.CopyTo(myTargetArray, 6)
        
        ' Displays the values of the Array.
        PrintValues(myTargetArray, " "c)
    End Sub    
    
    Public Shared Sub PrintValues(myArr As Array, mySeparator As Char)
        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("{0}{1}", mySeparator, myEnumerator.Current)
        End While
        Console.WriteLine()
    End Sub
End Class

' This code produces the following output.
' 
' The target Array contains the following (before and after copying):
'  The quick brown fox jumps over the lazy dog      
'  The quick brown fox jumps over three napping cats in the barn

Im folgenden Codebeispiel wird gezeigt, wie sie eine mit einer nichtzero-Untergrenze in ein Array anderes Array kopieren. Beachten Sie, dass die gesamte Quelle Array kopiert wird, einschließlich leerer Elemente, die vorhandene Elemente im Ziel Arrayüberschreiben.

using namespace System;

void main()
{
   // Creates and initializes the source Array.
   Array^ myArrayZero = Array::CreateInstance(String::typeid, 3);
   myArrayZero->SetValue("zero", 0);
   myArrayZero->SetValue("one", 1);

   // Displays the source Array.
   Console::WriteLine("The array with lowbound=0 contains:");
   PrintIndexAndValues(myArrayZero);

   // Creates and initializes the target Array.
   array<int>^myArrLen = {4};
   array<int>^myArrLow = {2};
   Array^ myArrayTwo = Array::CreateInstance(String::typeid, myArrLen, myArrLow);
   myArrayTwo->SetValue("two", 2);
   myArrayTwo->SetValue("three", 3);
   myArrayTwo->SetValue("four", 4);
   myArrayTwo->SetValue("five", 5);

   // Displays the target Array.
   Console::WriteLine("The array with lowbound=2 contains:");
   PrintIndexAndValues(myArrayTwo);

   // Copy from the array with lowbound=0 to the array with lowbound=2.
   myArrayZero->CopyTo(myArrayTwo, 3);

   // Displays the modified target Array.
   Console::WriteLine("\nAfter copying at relative index 1:");
   PrintIndexAndValues(myArrayTwo);
}

void PrintIndexAndValues(Array^ myArray)
{
   for (int i = myArray->GetLowerBound(0); i <= myArray->GetUpperBound(0); i++)
      Console::WriteLine("\t[{0}]:\t{1}", i, myArray->GetValue(i));
}

/* 
 This code produces the following output.
 
 The array with lowbound=0 contains:
     [0]:    zero
     [1]:    one
     [2]:    
 The array with lowbound=2 contains:
     [2]:    two
     [3]:    three
     [4]:    four
     [5]:    five
 
 After copying at relative index 1:
     [2]:    two
     [3]:    zero
     [4]:    one
     [5]:
 */

open System

let printIndexAndValues (myArray: Array) =
    for i = myArray.GetLowerBound 0 to myArray.GetUpperBound 0 do
        printfn $"\t[{i}]:\t{myArray.GetValue i}"

// Creates and initializes the source Array.
let myArrayZero = Array.zeroCreate 3
myArrayZero[0] <- "zero"
myArrayZero[1] <- "one"

// Displays the source Array.
printfn "The array with lower bound=0 contains:"
printIndexAndValues myArrayZero

// Creates and initializes the target Array.
let myArrLen = [| 4 |]
let myArrLow = [| 2 |]
let myArrayTwo = Array.CreateInstance(typeof<string>, myArrLen, myArrLow)
myArrayTwo.SetValue("two", 2)
myArrayTwo.SetValue("three", 3)
myArrayTwo.SetValue("four", 4)
myArrayTwo.SetValue("five", 5)

// Displays the target Array.
printfn "The array with lower bound=2 contains:"
printIndexAndValues myArrayTwo

// Copies from the array with lower bound=0 to the array with lower bound=2.
myArrayZero.CopyTo(myArrayTwo, 3)

// Displays the modified target Array.
printfn "\nAfter copying to the target array from index 3:"
printIndexAndValues myArrayTwo


// This code produces the following output.
//     The array with lower bound=0 contains:
//         [0]:    zero
//         [1]:    one
//         [2]:
//     The array with lower bound=2 contains:
//         [2]:    two
//         [3]:    three
//         [4]:    four
//         [5]:    five
//     
//     After copying to the target array from index 3:
//         [2]:    two
//         [3]:    zero
//         [4]:    one
//         [5]:

using System;

public class SamplesArray2
{

   public static void Main()
   {
      // Creates and initializes the source Array.
      Array myArrayZero=Array.CreateInstance(typeof(string), 3);
      myArrayZero.SetValue("zero", 0);
      myArrayZero.SetValue("one", 1);

      // Displays the source Array.
      Console.WriteLine("The array with lower bound=0 contains:");
      PrintIndexAndValues(myArrayZero);

      // Creates and initializes the target Array.
      int[] myArrLen = { 4 };
      int[] myArrLow = { 2 };
      Array myArrayTwo=Array.CreateInstance(typeof(string), myArrLen, myArrLow);
      myArrayTwo.SetValue("two", 2);
      myArrayTwo.SetValue("three", 3);
      myArrayTwo.SetValue("four", 4);
      myArrayTwo.SetValue("five", 5);

      // Displays the target Array.
      Console.WriteLine("The array with lower bound=2 contains:");
      PrintIndexAndValues(myArrayTwo);

      // Copies from the array with lower bound=0 to the array with lower bound=2.
      myArrayZero.CopyTo(myArrayTwo, 3);

      // Displays the modified target Array.
      Console.WriteLine("\nAfter copying to the target array from index 3:");
      PrintIndexAndValues(myArrayTwo);
   }

   public static void PrintIndexAndValues(Array myArray)
   {
      for (int i = myArray.GetLowerBound(0); i <= myArray.GetUpperBound(0); i++)
         Console.WriteLine("\t[{0}]:\t{1}", i, myArray.GetValue(i));
   }
}
/*
This code produces the following output.

The array with lower bound=0 contains:
    [0]:    zero
    [1]:    one
    [2]:
The array with lower bound=2 contains:
    [2]:    two
    [3]:    three
    [4]:    four
    [5]:    five

After copying to the target array from index 3:
    [2]:    two
    [3]:    zero
    [4]:    one
    [5]:
*/

Public Class SamplesArray2    
    
    Public Shared Sub Main()
        ' Creates and initializes the source Array.
        Dim myArrayZero As Array = Array.CreateInstance(GetType(String), 3)
        myArrayZero.SetValue("zero", 0)
        myArrayZero.SetValue("one", 1)
        
        ' Displays the source Array.
        Console.WriteLine("The array with lower bound=0 contains:")
        PrintIndexAndValues(myArrayZero)
        
        ' Creates and initializes the target Array.
        Dim myArrLen As Integer() = {4}
        Dim myArrLow As Integer() = {2}
        Dim myArrayTwo As Array = Array.CreateInstance(GetType(String), _
           myArrLen, myArrLow)
        myArrayTwo.SetValue("two", 2)
        myArrayTwo.SetValue("three", 3)
        myArrayTwo.SetValue("four", 4)
        myArrayTwo.SetValue("five", 5)
        
        ' Displays the target Array.
        Console.WriteLine("The array with lower bound=2 contains:")
        PrintIndexAndValues(myArrayTwo)
        
        ' Copies from the array with lower bound=0 to the array with lower bound=2.
        myArrayZero.CopyTo(myArrayTwo, 3)
        
        ' Displays the modified target Array.
        Console.WriteLine(ControlChars.Cr + "After copying to the target array from " _
           + "index 3:")
        PrintIndexAndValues(myArrayTwo)
    End Sub
    
    Public Shared Sub PrintIndexAndValues(myArray As Array)
        Dim i As Integer
        For i = myArray.GetLowerBound(0) To myArray.GetUpperBound(0)
            Console.WriteLine(ControlChars.Tab + "[{0}]:" + ControlChars.Tab _
               + "{1}", i, myArray.GetValue(i))
        Next i
    End Sub
End Class

' This code produces the following output.
' 
' The array with lower bound=0 contains:
'     [0]:    zero
'     [1]:    one
'     [2]:    
' The array with lower bound=2 contains:
'     [2]:    two
'     [3]:    three
'     [4]:    four
'     [5]:    five
' 
' After copying to the target array from index 3:
'     [2]:    two
'     [3]:    zero
'     [4]:    one
'     [5]:

CopyTo(Array, Int32)

Quelle:: Array.cs

Quelle:: Array.cs

Quelle:: Array.cs

Kopiert alle Elemente des aktuellen eindimensionalen Arrays in das angegebene eindimensionale Array, beginnend am angegebenen Index des Zielarrays. Der Index wird als 32-Bit-Ganzzahl angegeben.

public:
 virtual void CopyTo(Array ^ array, int index);

public void CopyTo (Array array, int index);

public virtual void CopyTo (Array array, int index);

abstract member CopyTo : Array * int -> unit
override this.CopyTo : Array * int -> unit

Public Sub CopyTo (array As Array, index As Integer)

Public Overridable Sub CopyTo (array As Array, index As Integer)

Parameter

array: Array

Das eindimensionale Array, das das Ziel der aus dem aktuellen Array kopierten Elemente ist.

index: Int32

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

Implementiert

CopyTo(Array, Int32)

Ausnahmen

ArgumentNullException

array ist null.

ArgumentOutOfRangeException

index ist kleiner als die untere array-Grenze.

ArgumentException

array ist mehrdimensional.

- oder -

Die Anzahl der Elemente im Quellarray ist größer als die verfügbare Anzahl der Elemente vom index bis zum Ende des Ziel-arrays.

ArrayTypeMismatchException

Der Typ der Quell-Array kann nicht automatisch in den Typ des Ziel-array umgewandelt werden.

RankException

Das Quellarray ist mehrdimensional.

InvalidCastException

Mindestens ein Element im Quell-Array kann nicht in den Typ des Ziel-arrays umgewandelt werden.

Hinweise

Diese Methode kopiert alle Elemente der aktuellen Arrayinstanz ab index indexin das array Zielarray. Das array Zielarray muss bereits dimensioniert worden sein und muss über eine ausreichende Anzahl von Elementen verfügen, um die kopierten Elemente aufzunehmen. Andernfalls löst die Methode eine Ausnahme aus.

Diese Methode unterstützt die System.Collections.ICollection Schnittstelle. Wenn die Implementierung System.Collections.ICollection nicht explizit erforderlich ist, verwenden Sie Copy , um eine zusätzliche Indirektierung zu vermeiden.

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

Diese Methode ist ein O()n-Vorgang, wobei n ist Length. Es führt nur eine flache Kopie aus.

Weitere Informationen

Gilt für:

CopyTo(Array, Int64)

Quelle:: Array.cs

Quelle:: Array.cs

Quelle:: Array.cs

Kopiert alle Elemente des aktuellen eindimensionalen Arrays in das angegebene eindimensionale Array, beginnend am angegebenen Index des Zielarrays. Der Index wird als 64-Bit-Ganzzahl angegeben.

public:
 void CopyTo(Array ^ array, long index);

public:
 virtual void CopyTo(Array ^ array, long index);

public void CopyTo (Array array, long index);

[System.Runtime.InteropServices.ComVisible(false)]
public virtual void CopyTo (Array array, long index);

[System.Runtime.InteropServices.ComVisible(false)]
public void CopyTo (Array array, long index);

member this.CopyTo : Array * int64 -> unit

[<System.Runtime.InteropServices.ComVisible(false)>]
abstract member CopyTo : Array * int64 -> unit
override this.CopyTo : Array * int64 -> unit

[<System.Runtime.InteropServices.ComVisible(false)>]
member this.CopyTo : Array * int64 -> unit

Public Sub CopyTo (array As Array, index As Long)

Public Overridable Sub CopyTo (array As Array, index As Long)

Parameter

array: Array

Das eindimensionale Array, das das Ziel der aus dem aktuellen Array kopierten Elemente ist.

index: Int64

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

Attribute: ComVisibleAttribute

Ausnahmen

ArgumentNullException

array ist null.

ArgumentOutOfRangeException

index liegt außerhalb des Bereichs der gültigen Indizes für array.

ArgumentException

array ist mehrdimensional.

- oder -

Die Anzahl der Elemente im Quellarray ist größer als die verfügbare Anzahl der Elemente vom index bis zum Ende des Ziel-arrays.

ArrayTypeMismatchException

Der Typ der Quell-Array kann nicht automatisch in den Typ des Ziel-array umgewandelt werden.

RankException

Das Quell-Array ist mehrdimensional.

InvalidCastException

Mindestens ein Element im Quell-Array kann nicht in den Typ des Ziel-arrays umgewandelt werden.

Hinweise

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

Diese Methode ist ein O()n-Vorgang, wobei n ist Length. Es führt nur eine flache Kopie aus.

Weitere Informationen

Gilt für:

Teilen über

Array.CopyTo Methode

Definition

Überlädt

Beispiele

CopyTo(Array, Int32)

Parameter

Implementiert

Ausnahmen

Hinweise

Weitere Informationen

Gilt für:

CopyTo(Array, Int64)

Parameter

Ausnahmen

Hinweise

Weitere Informationen

Gilt für:

Zusätzliche Ressourcen