Array.Copy 方法

定义

命名空间:: System

程序集:: netstandard.dll, System.Runtime.dll

程序集:: System.Runtime.dll

程序集:: mscorlib.dll

程序集:: netstandard.dll

程序集:: mscorlib.dll, System.Runtime.dll

重要

一些信息与预发行产品相关，相应产品在发行之前可能会进行重大修改。对于此处提供的信息，Microsoft 不作任何明示或暗示的担保。

将一系列元素复制到另一个Array Array元素，并根据需要执行类型转换和装箱。

重载

名称	说明
Copy(Array, Int64, Array, Int64, Int64)	从 Array 指定源索引处开始复制一系列元素，并将其粘贴到从指定目标索引处开始的另一个 Array 元素。长度和索引指定为 64 位整数。
Copy(Array, Int32, Array, Int32, Int32)	从 Array 指定源索引处开始复制一系列元素，并将其粘贴到从指定目标索引处开始的另一个 Array 元素。长度和索引指定为 32 位整数。
Copy(Array, Array, Int32)	从第一个 Array 元素开始复制一系列元素，并将其粘贴到第一个元素的另一个 Array 元素中。长度指定为 32 位整数。
Copy(Array, Array, Int64)	从第一个 Array 元素开始复制一系列元素，并将其粘贴到第一个元素的另一个 Array 元素中。长度指定为 64 位整数。

示例

下面的代码示例演示如何从一种类型Array复制到另一Object Array个类型整数。

open System

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

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

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

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

// Copies the first element from the int array to the Object array.
Array.Copy(myIntArray, myIntArray.GetLowerBound 0, myObjArray, myObjArray.GetLowerBound 0, 1)

// Copies the last two elements from the Object array to the int array.
Array.Copy(myObjArray, myObjArray.GetUpperBound 0 - 1, myIntArray, myIntArray.GetUpperBound 0 - 1, 2)

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


// This code produces the following output.
//     int array:
//         1    2    3    4    5
//     Object array:
//         26    27    28    29    30
//     int array - Last two elements should now be the same as Object array:
//         1    2    3    29    30
//     Object array - First element should now be the same as int array:
//         1    27    28    29    30

using System;
public class SamplesArray  {

   public static void Main()  {

      // Creates and initializes a new Array of type int.
      Array myIntArray=Array.CreateInstance( typeof(System.Int32), 5 );
      for ( int i = myIntArray.GetLowerBound(0); i <= myIntArray.GetUpperBound(0); i++ )
         myIntArray.SetValue( i+1, i );

      // Creates and initializes a new Array of type Object.
      Array myObjArray = Array.CreateInstance( typeof(System.Object), 5 );
      for ( int i = myObjArray.GetLowerBound(0); i <= myObjArray.GetUpperBound(0); i++ )
         myObjArray.SetValue( i+26, i );

      // Displays the initial values of both arrays.
      Console.WriteLine( "int array:" );
      PrintValues( myIntArray );
      Console.WriteLine( "Object array:" );
      PrintValues( myObjArray );

      // Copies the first element from the int array to the Object array.
      Array.Copy( myIntArray, myIntArray.GetLowerBound(0), myObjArray, myObjArray.GetLowerBound(0), 1 );

      // Copies the last two elements from the Object array to the int array.
      Array.Copy( myObjArray, myObjArray.GetUpperBound(0) - 1, myIntArray, myIntArray.GetUpperBound(0) - 1, 2 );

      // Displays the values of the modified arrays.
      Console.WriteLine( "int array - Last two elements should now be the same as Object array:" );
      PrintValues( myIntArray );
      Console.WriteLine( "Object array - First element should now be the same as int array:" );
      PrintValues( myObjArray );
   }

   public static void PrintValues( Array myArr )  {
      System.Collections.IEnumerator myEnumerator = myArr.GetEnumerator();
      int i = 0;
      int cols = myArr.GetLength( myArr.Rank - 1 );
      while ( myEnumerator.MoveNext() )  {
         if ( i < cols )  {
            i++;
         } else  {
            Console.WriteLine();
            i = 1;
         }
         Console.Write( "\t{0}", myEnumerator.Current );
      }
      Console.WriteLine();
   }
}
/*
This code produces the following output.

int array:
    1    2    3    4    5
Object array:
    26    27    28    29    30
int array - Last two elements should now be the same as Object array:
    1    2    3    29    30
Object array - First element should now be the same as int array:
    1    27    28    29    30
*/

Public Class SamplesArray    
    
    Public Shared Sub Main()
        
        ' Creates and initializes a new Array of type Int32.
        Dim myIntArray As Array = _
           Array.CreateInstance(GetType(System.Int32), 5)
        Dim i As Integer
        For i = myIntArray.GetLowerBound(0) To myIntArray.GetUpperBound(0)
            myIntArray.SetValue(i + 1, i)
        Next i 
        ' Creates and initializes a new Array of type Object.
        Dim myObjArray As Array = _
           Array.CreateInstance(GetType(System.Object), 5)
        For i = myObjArray.GetLowerBound(0) To myObjArray.GetUpperBound(0)
            myObjArray.SetValue(i + 26, i)
        Next i 
        ' Displays the initial values of both arrays.
        Console.WriteLine("Int32 array:")
        PrintValues(myIntArray)
        Console.WriteLine("Object array:")
        PrintValues(myObjArray)
        
        ' Copies the first element from the Int32 array to the Object array.
        Array.Copy(myIntArray, myIntArray.GetLowerBound(0), myObjArray, _
           myObjArray.GetLowerBound(0), 1)
        
        ' Copies the last two elements from the Object array to the Int32 array.
        Array.Copy(myObjArray, myObjArray.GetUpperBound(0) - 1, myIntArray, _
           myIntArray.GetUpperBound(0) - 1, 2)
        
        ' Displays the values of the modified arrays.
        Console.WriteLine("Int32 array - Last two elements should now be " _
           + "the same as Object array:")
        PrintValues(myIntArray)
        Console.WriteLine("Object array - First element should now be the " _
           + "same as Int32 array:")
        PrintValues(myObjArray)
    End Sub
    
    Public Shared Sub PrintValues(myArr As Array)
        Dim myEnumerator As System.Collections.IEnumerator = _
           myArr.GetEnumerator()
        Dim i As Integer = 0
        Dim cols As Integer = myArr.GetLength((myArr.Rank - 1))
        While myEnumerator.MoveNext()
            If i < cols Then
                i += 1
            Else
                Console.WriteLine()
                i = 1
            End If
            Console.Write(ControlChars.Tab + "{0}", myEnumerator.Current)
        End While
        Console.WriteLine()
    End Sub
End Class

' This code produces the following output.
' 
' Int32 array:
'     1    2    3    4    5
' Object array:
'     26    27    28    29    30
' Int32 array - Last two elements should now be the same as Object array:
'     1    2    3    29    30
' Object array - First element should now be the same as Int32 array:
'     1    27    28    29    30

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

Source:: Array.cs

Source:: Array.cs

Source:: Array.cs

Source:: Array.cs

Source:: Array.cs

从 Array 指定源索引处开始复制一系列元素，并将其粘贴到从指定目标索引处开始的另一个 Array 元素。长度和索引指定为 64 位整数。

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)

参数

sourceArray: Array

Array包含要复制的数据。

sourceIndex: Int64

一个 64 位整数，表示开始复制的索引 sourceArray 。

destinationArray: Array

Array接收数据的数据。

destinationIndex: Int64

一个 64 位整数，表示存储开始处的索引 destinationArray 。

length: Int64

一个 64 位整数，表示要复制的元素数。整数必须介于零和 Int32.MaxValue 之间（含）。

例外

ArgumentNullException

sourceArray 是 null。

-或-

destinationArray 是 null。

RankException

sourceArray 并 destinationArray 具有不同的排名。

ArrayTypeMismatchException

sourceArray 并且 destinationArray 属于不兼容的类型。

InvalidCastException

不能将至少一个元素 sourceArray 强制转换为类型 destinationArray。

ArgumentOutOfRangeException

sourceIndex 超出有效索引 sourceArray的范围。

-或-

destinationIndex 超出有效索引 destinationArray的范围。

-或-

length 小于 0 或大于 Int32.MaxValue。

ArgumentException

length 大于从 sourceIndex 元素到末尾的 sourceArray元素数。

-或-

length 大于从 destinationIndex 元素到末尾的 destinationArray元素数。

注解

参数sourceArraydestinationArray必须具有相同数量的维度。此外， destinationArray 必须已对维度进行了维度，并且必须具有足够数量的元素，从 destinationIndex 位置开始容纳复制的数据。

在多维数组之间复制时，数组的行为类似于长一维数组，其中行（或列）在概念上是端到端布局的。例如，如果数组具有三行（或列），其中每个元素有四个元素，则从数组开头复制六个元素将复制第一行（或列）和第二行的前两个元素（或列）。若要开始从第三行（或列）的第二个元素进行复制， sourceIndex 必须是第一行（或列）的上限加上第二行（或列）的长度加 2。

如果sourceArray和destinationArray重叠，此方法的行为就像在覆盖之前sourceArray在临时位置保留的原始值destinationArray一样。

[C++]

此方法等效于标准 C/C++ 函数 memmove，而不是 memcpy。

这些数组可以是引用类型数组或值类型数组。根据需要执行类型向下转换。

从引用类型数组复制到值类型数组时，将取消装箱并复制每个元素。从值类型数组复制到引用类型数组时，将装箱并复制每个元素。
从引用类型或值类型数组复制到数组时，将创建一个Object Object用于保存每个值或引用，然后复制。从 Object 数组复制到引用类型或值类型数组且无法执行赋值时，将引发赋 InvalidCastException 值。
sourceArray如果destinationArray同时是引用类型数组或两个类型Object数组，则执行浅表复制。浅表副本 Array 是一个新的 Array 包含对与原始 Array元素相同的元素的引用。不会复制元素本身或元素引用的任何内容。相比之下，元素的深层副本 Array 将复制元素以及元素直接或间接引用的所有内容。

如果数组的类型不兼容，则会引发 an ArrayTypeMismatchException 。类型兼容性的定义如下：

类型与自身兼容。
值类型与 Object 该值类型实现的接口类型兼容，仅当值类型直接实现该接口时，才会将其视为连接到接口。断开连接的类型不兼容。
如果从源类型复制到目标类型是扩大转换，则两种内部（预定义）值类型兼容。扩大转换永远不会丢失信息，而缩小转换可能会丢失信息。例如，将 32 位有符号整数转换为 64 位有符号整数是一种加宽转换，将 64 位带符号整数转换为 32 位有符号整数是一种缩小转换。有关转换的详细信息，请参阅 Convert。
非内部值类型（用户定义的）值类型仅与自身兼容。
枚举对其基础类型具有隐式转换 Enum 。

如果每个元素 sourceArray 都需要向下转换（例如，从基类到派生类或从接口转换为对象），并且无法将一个或多个元素强制转换为相应的类型 destinationArray，则会引发一个 InvalidCastException 。

如果此方法在复制时引发异常，则状态 destinationArray 为未定义。

此方法是 O（n）操作，其中 n 。length

另请参阅

适用于

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

Source:: Array.cs

Source:: Array.cs

Source:: Array.CoreCLR.cs

Source:: Array.cs

Source:: Array.cs

从 Array 指定源索引处开始复制一系列元素，并将其粘贴到从指定目标索引处开始的另一个 Array 元素。长度和索引指定为 32 位整数。

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)

参数

sourceArray: Array

Array包含要复制的数据。

sourceIndex: Int32

一个 32 位整数，表示开始复制的索引 sourceArray 。

destinationArray: Array

Array接收数据的数据。

destinationIndex: Int32

一个 32 位整数，表示存储开始处的索引 destinationArray 。

length: Int32

一个 32 位整数，表示要复制的元素数。

例外

ArgumentNullException

sourceArray 是 null。

-或-

destinationArray 是 null。

RankException

sourceArray 并 destinationArray 具有不同的排名。

ArrayTypeMismatchException

sourceArray 并且 destinationArray 属于不兼容的类型。

InvalidCastException

不能将至少一个元素 sourceArray 强制转换为类型 destinationArray。

ArgumentOutOfRangeException

sourceIndex 小于第一个维度的 sourceArray下限。

-或-

destinationIndex 小于第一个维度的 destinationArray下限。

-或-

length 小于零。

ArgumentException

length 大于从 sourceIndex 元素到末尾的 sourceArray元素数。

-或-

length 大于从 destinationIndex 元素到末尾的 destinationArray元素数。

注解

如果sourceArray和destinationArray重叠，此方法的行为就像在覆盖之前sourceArray在临时位置保留的原始值destinationArray一样。

[C++]

此方法等效于标准 C/C++ 函数 memmove，而不是 memcpy。

这些数组可以是引用类型数组或值类型数组。根据需要执行类型向下转换。

从引用类型数组复制到值类型数组时，将取消装箱并复制每个元素。从值类型数组复制到引用类型数组时，将装箱并复制每个元素。
从引用类型或值类型数组复制到数组时，将创建一个Object Object用于保存每个值或引用，然后复制。从 Object 数组复制到引用类型或值类型数组且无法执行赋值时，将引发赋 InvalidCastException 值。
sourceArray如果destinationArray同时是引用类型数组或两个类型Object数组，则执行浅表复制。浅表副本 Array 是一个新的 Array 包含对与原始 Array元素相同的元素的引用。不会复制元素本身或元素引用的任何内容。相比之下，元素的深层副本 Array 将复制元素以及元素直接或间接引用的所有内容。

如果数组的类型不兼容，则会引发 an ArrayTypeMismatchException 。类型兼容性的定义如下：

类型与自身兼容。
值类型与 Object 该值类型实现的接口类型兼容，仅当值类型直接实现该接口时，才会将其视为连接到接口。断开连接的类型不兼容。
如果从源类型复制到目标类型是扩大转换，则两种内部（预定义）值类型兼容。扩大转换永远不会丢失信息，而缩小转换可能会丢失信息。例如，将 32 位有符号整数转换为 64 位有符号整数是一种加宽转换，将 64 位带符号整数转换为 32 位有符号整数是一种缩小转换。有关转换的详细信息，请参阅 Convert。
非内部值类型（用户定义的）值类型仅与自身兼容。
枚举对其基础类型具有隐式转换 Enum 。

如果此方法在复制时引发异常，则状态 destinationArray 为未定义。

此方法是 O（n）操作，其中 n 。length

另请参阅

适用于

Copy(Array, Array, Int32)

Source:: Array.cs

Source:: Array.cs

Source:: Array.CoreCLR.cs

Source:: Array.cs

Source:: Array.cs

从第一个 Array 元素开始复制一系列元素，并将其粘贴到第一个元素的另一个 Array 元素中。长度指定为 32 位整数。

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)

参数

sourceArray: Array

Array包含要复制的数据。

destinationArray: Array

Array接收数据的数据。

length: Int32

一个 32 位整数，表示要复制的元素数。

例外

ArgumentNullException

sourceArray 是 null。

-或-

destinationArray 是 null。

RankException

sourceArray 并 destinationArray 具有不同的排名。

ArrayTypeMismatchException

sourceArray 并且 destinationArray 属于不兼容的类型。

InvalidCastException

不能将至少一个元素 sourceArray 强制转换为类型 destinationArray。

ArgumentOutOfRangeException

length 小于零。

ArgumentException

length 大于 . 中的 sourceArray元素数。

-或-

length 大于 . 中的 destinationArray元素数。

注解

参数sourceArraydestinationArray必须具有相同数量的维度。此外， destinationArray 必须已对数据进行维度化，并且必须有足够的元素来容纳复制的数据。

在多维数组之间复制时，数组的行为类似于长一维数组，其中行（或列）在概念上是端到端的。例如，如果数组具有三行（或列），其中每个元素有四个元素，则从数组开头复制六个元素将复制第一行（或列）和第二行的前两个元素（或列）。

如果sourceArray和destinationArray重叠，此方法的行为就像在覆盖之前sourceArray在临时位置保留的原始值destinationArray一样。

[C++]

此方法等效于标准 C/C++ 函数 memmove，而不是 memcpy。

这些数组可以是引用类型数组或值类型数组。根据需要执行类型向下转换。

从引用类型数组复制到值类型数组时，将取消装箱并复制每个元素。从值类型数组复制到引用类型数组时，将装箱并复制每个元素。
从引用类型或值类型数组复制到数组时，将创建一个Object Object用于保存每个值或引用，然后复制。从 Object 数组复制到引用类型或值类型数组且无法执行赋值时，将引发赋 InvalidCastException 值。
sourceArray如果destinationArray同时是引用类型数组或两个类型Object数组，则执行浅表复制。浅表副本 Array 是一个新的 Array 包含对与原始 Array元素相同的元素的引用。不会复制元素本身或元素引用的任何内容。相比之下，元素的深层副本 Array 将复制元素以及元素直接或间接引用的所有内容。

如果数组的类型不兼容，则会引发 an ArrayTypeMismatchException 。类型兼容性的定义如下：

类型与自身兼容。
值类型与 Object 该值类型实现的接口类型兼容，仅当值类型直接实现该接口时，才会将其视为连接到接口。断开连接的类型不兼容。
如果从源类型复制到目标类型是扩大转换，则两种内部（预定义）值类型兼容。扩大转换永远不会丢失信息，而缩小转换可能会丢失信息。例如，将 32 位有符号整数转换为 64 位有符号整数是一种加宽转换，将 64 位带符号整数转换为 32 位有符号整数是一种缩小转换。有关转换的详细信息，请参阅 Convert。
非内部值类型（用户定义的）值类型仅与自身兼容。
枚举对其基础类型具有隐式转换 Enum 。

如果此方法在复制时引发异常，则状态 destinationArray 为未定义。

此方法是 O（n）操作，其中 n 。length

另请参阅

适用于

Copy(Array, Array, Int64)

Source:: Array.cs

Source:: Array.cs

Source:: Array.cs

Source:: Array.cs

Source:: Array.cs

从第一个 Array 元素开始复制一系列元素，并将其粘贴到第一个元素的另一个 Array 元素中。长度指定为 64 位整数。

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)

参数

sourceArray: Array

Array包含要复制的数据。

destinationArray: Array

Array接收数据的数据。

length: Int64

一个 64 位整数，表示要复制的元素数。整数必须介于零和 Int32.MaxValue 之间（含）。

例外

ArgumentNullException

sourceArray 是 null。

-或-

destinationArray 是 null。

RankException

sourceArray 并 destinationArray 具有不同的排名。

ArrayTypeMismatchException

sourceArray 并且 destinationArray 属于不兼容的类型。

InvalidCastException

不能将至少一个元素 sourceArray 强制转换为类型 destinationArray。

ArgumentOutOfRangeException

length 小于 0 或大于 Int32.MaxValue。

ArgumentException

length 大于 . 中的 sourceArray元素数。

-或-

length 大于 . 中的 destinationArray元素数。

注解

参数sourceArraydestinationArray必须具有相同数量的维度。此外， destinationArray 必须已对数据进行维度化，并且必须有足够的元素来容纳复制的数据。

如果sourceArray和destinationArray重叠，此方法的行为就像在覆盖之前sourceArray在临时位置保留的原始值destinationArray一样。

[C++]

此方法等效于标准 C/C++ 函数 memmove，而不是 memcpy。

这些数组可以是引用类型数组或值类型数组。根据需要执行类型向下转换。

从引用类型数组复制到值类型数组时，将取消装箱并复制每个元素。从值类型数组复制到引用类型数组时，将装箱并复制每个元素。
从引用类型或值类型数组复制到数组时，将创建一个Object Object用于保存每个值或引用，然后复制。从 Object 数组复制到引用类型或值类型数组且无法执行赋值时，将引发赋 InvalidCastException 值。
sourceArray如果destinationArray同时是引用类型数组或两个类型Object数组，则执行浅表复制。浅表副本 Array 是一个新的 Array 包含对与原始 Array元素相同的元素的引用。不会复制元素本身或元素引用的任何内容。相比之下，元素的深层副本 Array 将复制元素以及元素直接或间接引用的所有内容。

如果数组的类型不兼容，则会引发 an ArrayTypeMismatchException 。类型兼容性的定义如下：

类型与自身兼容。
值类型与 Object 该值类型实现的接口类型兼容，仅当值类型直接实现该接口时，才会将其视为连接到接口。断开连接的类型不兼容。
如果从源类型复制到目标类型是扩大转换，则两种内部（预定义）值类型兼容。扩大转换永远不会丢失信息，而缩小转换可能会丢失信息。例如，将 32 位有符号整数转换为 64 位有符号整数是一种加宽转换，将 64 位带符号整数转换为 32 位有符号整数是一种缩小转换。有关转换的详细信息，请参阅 Convert。
非内部值类型（用户定义的）值类型仅与自身兼容。
枚举对其基础类型具有隐式转换 Enum 。

如果此方法在复制时引发异常，则状态 destinationArray 为未定义。

此方法是 O（n）操作，其中 n 。length

另请参阅

适用于

反馈

此页面是否有帮助？