Buffer.BlockCopy(Array, Int32, Array, Int32, Int32) 方法

参考

定义

命名空间:: System

程序集:: System.Runtime.dll

程序集:: mscorlib.dll

程序集:: netstandard.dll

Source:: Buffer.cs

Source:: Buffer.cs

Source:: Buffer.cs

重要

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

将指定数目的字节从起始于特定偏移量的源数组复制到起始于特定偏移量的目标数组。

public:
 static void BlockCopy(Array ^ src, int srcOffset, Array ^ dst, int dstOffset, int count);

public static void BlockCopy (Array src, int srcOffset, Array dst, int dstOffset, int count);

static member BlockCopy : Array * int * Array * int * int -> unit

Public Shared Sub BlockCopy (src As Array, srcOffset As Integer, dst As Array, dstOffset As Integer, count As Integer)

参数

src: Array

源缓冲区。

srcOffset: Int32

src 中的字节偏移量，从零开始。

dst: Array

目标缓冲区。

dstOffset: Int32

dst 中的字节偏移量，从零开始。

count: Int32

要复制的字节数。

例外

ArgumentNullException

src 或 dst 为 null。

ArgumentException

src 或 dst 不是基元数组。

- 或 -

src 中的字节数小于 srcOffset 加上count 之和。

- 或 -

dst 中的字节数小于 dstOffset 加上count 之和。

ArgumentOutOfRangeException

srcOffset、dstOffset 或 count 小于 0。

示例

以下示例使用 BlockCopy 方法复制数组的区域。对于每个 BlockCopy 操作，它将源数组和目标数组作为值数组和字节序列列出。该示例演示了在使用 BlockCopy 方法时考虑系统结束项的重要性：由于 Windows 系统是小 endian，因此基元数据类型值的低阶字节先于高阶字节。

using namespace System;

// Display the individual bytes in the array in hexadecimal.
void DisplayArray(System::Array^ arr, String^ name)
{
   Console::WindowWidth = 120;
   Console::Write("{0,11}:", name);
   for (int ctr = 0; ctr < arr->Length; ctr++)
   {
      array<Byte>^ bytes;
      if (arr->GetType() == array<Int64>::typeid)      
         bytes = BitConverter::GetBytes((Int64) arr->GetValue(ctr));
      else
         bytes = BitConverter::GetBytes((Int16) arr->GetValue(ctr));

      for each (Byte byteValue in bytes)
         Console::Write(" {0:X2}", byteValue);
   }
   Console::WriteLine();
}

// Display the individual array element values in hexadecimal.
void DisplayArrayValues(Array^ arr, String^ name)
{
   // Get the length of one element in the array.
   int elementLength = Buffer::ByteLength(arr) / arr->Length;
   String^ formatString = String::Format(" {{0:X{0}}}", 2 * elementLength);
   Console::Write( "{0,11}:", name);
   for (int ctr = 0; ctr < arr->Length; ctr++)
      Console::Write(formatString, arr->GetValue(ctr));

   Console::WriteLine();
}

void main()
{
   // These are the source and destination arrays for BlockCopy.
   array<Int16>^ src = gcnew array<Int16> { 258, 259, 260, 261, 262, 263, 264, 
                                            265, 266, 267, 268, 269, 270 };
   array<Int64>^ dest = gcnew array<Int64> { 17, 18, 19, 20 };

   // Display the initial value of the arrays in memory.
   Console::WriteLine( "Initial values of arrays:");
   Console::WriteLine("   Array values as Bytes:");
   DisplayArray(src, "src" );
   DisplayArray(dest, "dest");
   Console::WriteLine("   Array values:");
   DisplayArrayValues(src, "src");
   DisplayArrayValues(dest, "dest");
   Console::WriteLine();

   // Copy bytes 5-10 from source to index 7 in destination and display the result.
   Buffer::BlockCopy(src, 5, dest, 7, 6);
   Console::WriteLine("Buffer::BlockCopy(src, 5, dest, 7, 6 )");
   Console::WriteLine("   Array values as Bytes:");
   DisplayArray(src, "src");
   DisplayArray(dest, "dest");
   Console::WriteLine("   Array values:");
   DisplayArrayValues(src, "src");
   DisplayArrayValues(dest, "dest");
   Console::WriteLine();

   // Copy bytes 16-20 from source to index 22 in destination and display the result. 
   Buffer::BlockCopy(src, 16, dest, 22, 5);
   Console::WriteLine("Buffer.BlockCopy(src, 16, dest, 22, 5)");
   Console::WriteLine("   Array values as Bytes:");
   DisplayArray(src, "src");
   DisplayArray(dest, "dest");
   Console::WriteLine("   Array values:");
   DisplayArrayValues(src, "src");
   DisplayArrayValues(dest, "dest");
   Console::WriteLine();

   // Copy overlapping range of bytes 4-10 to index 5 in source.
   Buffer::BlockCopy(src, 4, src, 5, 7 );
   Console::WriteLine("Buffer.BlockCopy( src, 4, src, 5, 7)");
   Console::WriteLine("   Array values as Bytes:");
   DisplayArray(src, "src");
   DisplayArray(dest, "dest");
   Console::WriteLine("   Array values:");
   DisplayArrayValues(src, "src");
   DisplayArrayValues(dest, "dest");
   Console::WriteLine();

   // Copy overlapping range of bytes 16-22 to index 15 in source. 
   Buffer::BlockCopy(src, 16, src, 15, 7);
   Console::WriteLine("Buffer.BlockCopy( src, 16, src, 15, 7)");
   Console::WriteLine("   Array values as Bytes:");
   DisplayArray(src, "src");
   DisplayArray(dest, "dest");
   Console::WriteLine("   Array values:");
   DisplayArrayValues(src, "src");
}
// The example displays the following output:
//    Initial values of arrays:
//       Array values as Bytes:
//            src: 02 01 03 01 04 01 05 01 06 01 07 01 08 01 09 01 0A 01 0B 01 0C 01 0D 01 0E 01
//           dest: 11 00 00 00 00 00 00 00 12 00 00 00 00 00 00 00 13 00 00 00 00 00 00 00 14 00 00 00 00 00 00 00
//       Array values:
//            src: 0102 0103 0104 0105 0106 0107 0108 0109 010A 010B 010C 010D 010E
//           dest: 0000000000000011 0000000000000012 0000000000000013 0000000000000014
//    
//    Buffer.BlockCopy(src, 5, dest, 7, 6 )
//       Array values as Bytes:
//            src: 02 01 03 01 04 01 05 01 06 01 07 01 08 01 09 01 0A 01 0B 01 0C 01 0D 01 0E 01
//           dest: 11 00 00 00 00 00 00 01 05 01 06 01 07 00 00 00 13 00 00 00 00 00 00 00 14 00 00 00 00 00 00 00
//       Array values:
//            src: 0102 0103 0104 0105 0106 0107 0108 0109 010A 010B 010C 010D 010E
//           dest: 0100000000000011 0000000701060105 0000000000000013 0000000000000014
//    
//    Buffer.BlockCopy(src, 16, dest, 22, 5)
//       Array values as Bytes:
//            src: 02 01 03 01 04 01 05 01 06 01 07 01 08 01 09 01 0A 01 0B 01 0C 01 0D 01 0E 01
//           dest: 11 00 00 00 00 00 00 01 05 01 06 01 07 00 00 00 13 00 00 00 00 00 0A 01 0B 01 0C 00 00 00 00 00
//       Array values:
//            src: 0102 0103 0104 0105 0106 0107 0108 0109 010A 010B 010C 010D 010E
//           dest: 0100000000000011 0000000701060105 010A000000000013 00000000000C010B
//    
//    Buffer.BlockCopy( src, 4, src, 5, 7)
//       Array values as Bytes:
//            src: 02 01 03 01 04 04 01 05 01 06 01 07 08 01 09 01 0A 01 0B 01 0C 01 0D 01 0E 01
//           dest: 11 00 00 00 00 00 00 01 05 01 06 01 07 00 00 00 13 00 00 00 00 00 0A 01 0B 01 0C 00 00 00 00 00
//       Array values:
//            src: 0102 0103 0404 0501 0601 0701 0108 0109 010A 010B 010C 010D 010E
//           dest: 0100000000000011 0000000701060105 010A000000000013 00000000000C010B
//    
//    Buffer.BlockCopy( src, 16, src, 15, 7)
//       Array values as Bytes:
//            src: 02 01 03 01 04 04 01 05 01 06 01 07 08 01 09 0A 01 0B 01 0C 01 0D 0D 01 0E 01
//           dest: 11 00 00 00 00 00 00 01 05 01 06 01 07 00 00 00 13 00 00 00 00 00 0A 01 0B 01 0C 00 00 00 00 00
//       Array values:
//            src: 0102 0103 0404 0501 0601 0701 0108 0A09 0B01 0C01 0D01 010D 010E
//           dest: 0100000000000011 0000000701060105 010A000000000013 00000000000C010B

using System;

class Example
{
    // Display the individual bytes in the array in hexadecimal.
    public static void DisplayArray(Array arr, string name)
    {
        Console.WindowWidth = 120;
        Console.Write("{0,11}:", name);
        for (int ctr = 0; ctr < arr.Length; ctr++)
        {
            byte[] bytes;
            if (arr is long[])
               bytes = BitConverter.GetBytes((long) arr.GetValue(ctr));
            else
               bytes = BitConverter.GetBytes((short) arr.GetValue(ctr));

            foreach (byte byteValue in bytes)
               Console.Write(" {0:X2}", byteValue);
        }
        Console.WriteLine();
    }

    // Display the individual array element values in hexadecimal.
    public static void DisplayArrayValues(Array arr, string name)
    {
        // Get the length of one element in the array.
        int elementLength = Buffer.ByteLength(arr) / arr.Length;
        string formatString = String.Format(" {{0:X{0}}}", 2 * elementLength);
        Console.Write( "{0,11}:", name);
        for (int ctr = 0; ctr < arr.Length; ctr++)
            Console.Write(formatString, arr.GetValue(ctr));

        Console.WriteLine();
    }

    public static void Main( )
    {
        // These are the source and destination arrays for BlockCopy.
        short[] src  = { 258, 259, 260, 261, 262, 263, 264,
                          265, 266, 267, 268, 269, 270 };
        long[] dest = { 17, 18, 19, 20 };

        // Display the initial value of the arrays in memory.
        Console.WriteLine( "Initial values of arrays:");
        Console.WriteLine("   Array values as Bytes:");
        DisplayArray(src, "src" );
        DisplayArray(dest, "dest");
        Console.WriteLine("   Array values:");
        DisplayArrayValues(src, "src");
        DisplayArrayValues(dest, "dest");
        Console.WriteLine();

        // Copy bytes 5-10 from source to index 7 in destination and display the result.
        Buffer.BlockCopy(src, 5, dest, 7, 6);
        Console.WriteLine("Buffer.BlockCopy(src, 5, dest, 7, 6 )");
        Console.WriteLine("   Array values as Bytes:");
        DisplayArray(src, "src");
        DisplayArray(dest, "dest");
        Console.WriteLine("   Array values:");
        DisplayArrayValues(src, "src");
        DisplayArrayValues(dest, "dest");
        Console.WriteLine();

        // Copy bytes 16-20 from source to index 22 in destination and display the result.
        Buffer.BlockCopy(src, 16, dest, 22, 5);
        Console.WriteLine("Buffer.BlockCopy(src, 16, dest, 22, 5)");
        Console.WriteLine("   Array values as Bytes:");
        DisplayArray(src, "src");
        DisplayArray(dest, "dest");
        Console.WriteLine("   Array values:");
        DisplayArrayValues(src, "src");
        DisplayArrayValues(dest, "dest");
        Console.WriteLine();

        // Copy overlapping range of bytes 4-10 to index 5 in source.
        Buffer.BlockCopy(src, 4, src, 5, 7 );
        Console.WriteLine("Buffer.BlockCopy( src, 4, src, 5, 7)");
        Console.WriteLine("   Array values as Bytes:");
        DisplayArray(src, "src");
        DisplayArray(dest, "dest");
        Console.WriteLine("   Array values:");
        DisplayArrayValues(src, "src");
        DisplayArrayValues(dest, "dest");
        Console.WriteLine();

        // Copy overlapping range of bytes 16-22 to index 15 in source.
        Buffer.BlockCopy(src, 16, src, 15, 7);
        Console.WriteLine("Buffer.BlockCopy( src, 16, src, 15, 7)");
        Console.WriteLine("   Array values as Bytes:");
        DisplayArray(src, "src");
        DisplayArray(dest, "dest");
        Console.WriteLine("   Array values:");
        DisplayArrayValues(src, "src");
        DisplayArrayValues(dest, "dest");
    }
}
// The example displays the following output:
//    Initial values of arrays:
//       Array values as Bytes:
//            src: 02 01 03 01 04 01 05 01 06 01 07 01 08 01 09 01 0A 01 0B 01 0C 01 0D 01 0E 01
//           dest: 11 00 00 00 00 00 00 00 12 00 00 00 00 00 00 00 13 00 00 00 00 00 00 00 14 00 00 00 00 00 00 00
//       Array values:
//            src: 0102 0103 0104 0105 0106 0107 0108 0109 010A 010B 010C 010D 010E
//           dest: 0000000000000011 0000000000000012 0000000000000013 0000000000000014
//
//    Buffer.BlockCopy(src, 5, dest, 7, 6 )
//       Array values as Bytes:
//            src: 02 01 03 01 04 01 05 01 06 01 07 01 08 01 09 01 0A 01 0B 01 0C 01 0D 01 0E 01
//           dest: 11 00 00 00 00 00 00 01 05 01 06 01 07 00 00 00 13 00 00 00 00 00 00 00 14 00 00 00 00 00 00 00
//       Array values:
//            src: 0102 0103 0104 0105 0106 0107 0108 0109 010A 010B 010C 010D 010E
//           dest: 0100000000000011 0000000701060105 0000000000000013 0000000000000014
//
//    Buffer.BlockCopy(src, 16, dest, 22, 5)
//       Array values as Bytes:
//            src: 02 01 03 01 04 01 05 01 06 01 07 01 08 01 09 01 0A 01 0B 01 0C 01 0D 01 0E 01
//           dest: 11 00 00 00 00 00 00 01 05 01 06 01 07 00 00 00 13 00 00 00 00 00 0A 01 0B 01 0C 00 00 00 00 00
//       Array values:
//            src: 0102 0103 0104 0105 0106 0107 0108 0109 010A 010B 010C 010D 010E
//           dest: 0100000000000011 0000000701060105 010A000000000013 00000000000C010B
//
//    Buffer.BlockCopy( src, 4, src, 5, 7)
//       Array values as Bytes:
//            src: 02 01 03 01 04 04 01 05 01 06 01 07 08 01 09 01 0A 01 0B 01 0C 01 0D 01 0E 01
//           dest: 11 00 00 00 00 00 00 01 05 01 06 01 07 00 00 00 13 00 00 00 00 00 0A 01 0B 01 0C 00 00 00 00 00
//       Array values:
//            src: 0102 0103 0404 0501 0601 0701 0108 0109 010A 010B 010C 010D 010E
//           dest: 0100000000000011 0000000701060105 010A000000000013 00000000000C010B
//
//    Buffer.BlockCopy( src, 16, src, 15, 7)
//       Array values as Bytes:
//            src: 02 01 03 01 04 04 01 05 01 06 01 07 08 01 09 0A 01 0B 01 0C 01 0D 0D 01 0E 01
//           dest: 11 00 00 00 00 00 00 01 05 01 06 01 07 00 00 00 13 00 00 00 00 00 0A 01 0B 01 0C 00 00 00 00 00
//       Array values:
//            src: 0102 0103 0404 0501 0601 0701 0108 0A09 0B01 0C01 0D01 010D 010E
//           dest: 0100000000000011 0000000701060105 010A000000000013 00000000000C010B

open System

// Display the individual bytes in the array in hexadecimal.
let displayArray (arr: 'a []) (name: string) =
    Console.WindowWidth <- 120
    printf $"%11s{name}:"
    for i = 0 to arr.Length - 1 do
        let bytes =
            match box arr with 
            | :? array<int64> ->
                BitConverter.GetBytes(box arr[i] :?> int64)
            | _ ->
                BitConverter.GetBytes(box arr[i] :?> int16)
        for byteValue in bytes do
            printf $" %02X{byteValue}"
    printfn ""

// Display the individual array element values in hexadecimal.
let inline displayArrayValues (arr: ^a []) name =
    // Get the length of one element in the array.
    let elementLength = Buffer.ByteLength arr / arr.Length
    printf $"%11s{name}:"
    for value in arr do
        printf " %0*X" (2 * elementLength) value 
    printfn ""

// These are the source and destination arrays for BlockCopy.
let src =
    [| 258s; 259s; 260s; 261s; 262s; 263s; 264s
       265s; 266s; 267s; 268s; 269s; 270s |]

let dest = 
    [| 17L; 18L; 19L; 20L |]

// Display the initial value of the arrays in memory.
printfn "Initial values of arrays:"
printfn "   Array values as Bytes:"
displayArray src "src"
displayArray dest "dest"
printfn "   Array values:"
displayArrayValues src "src"
displayArrayValues dest "dest"
printfn ""

// Copy bytes 5-10 from source to index 7 in destination and display the result.
Buffer.BlockCopy(src, 5, dest, 7, 6)
printfn "Buffer.BlockCopy(src, 5, dest, 7, 6 )"
printfn "   Array values as Bytes:"
displayArray src "src"
displayArray dest "dest"
printfn "   Array values:"
displayArrayValues src "src"
displayArrayValues dest "dest"
printfn ""

// Copy bytes 16-20 from source to index 22 in destination and display the result.
Buffer.BlockCopy(src, 16, dest, 22, 5)
printfn "Buffer.BlockCopy(src, 16, dest, 22, 5)"
printfn "   Array values as Bytes:"
displayArray src "src"
displayArray dest "dest"
printfn "   Array values:"
displayArrayValues src "src"
displayArrayValues dest "dest"
printfn ""

// Copy overlapping range of bytes 4-10 to index 5 in source.
Buffer.BlockCopy(src, 4, src, 5, 7)
printfn "Buffer.BlockCopy(src, 4, src, 5, 7)"
printfn "   Array values as Bytes:"
displayArray src "src"
displayArray dest "dest"
printfn "   Array values:"
displayArrayValues src "src"
displayArrayValues dest "dest"
printfn ""

// Copy overlapping range of bytes 16-22 to index 15 in source.
Buffer.BlockCopy(src, 16, src, 15, 7)
printfn "Buffer.BlockCopy(src, 16, src, 15, 7)"
printfn "   Array values as Bytes:"
displayArray src "src"
displayArray dest "dest"
printfn "   Array values:"
displayArrayValues src "src"
displayArrayValues dest "dest"


// The example displays the following output:
//    Initial values of arrays:
//       Array values as Bytes:
//            src: 02 01 03 01 04 01 05 01 06 01 07 01 08 01 09 01 0A 01 0B 01 0C 01 0D 01 0E 01
//           dest: 11 00 00 00 00 00 00 00 12 00 00 00 00 00 00 00 13 00 00 00 00 00 00 00 14 00 00 00 00 00 00 00
//       Array values:
//            src: 0102 0103 0104 0105 0106 0107 0108 0109 010A 010B 010C 010D 010E
//           dest: 0000000000000011 0000000000000012 0000000000000013 0000000000000014
//
//    Buffer.BlockCopy(src, 5, dest, 7, 6 )
//       Array values as Bytes:
//            src: 02 01 03 01 04 01 05 01 06 01 07 01 08 01 09 01 0A 01 0B 01 0C 01 0D 01 0E 01
//           dest: 11 00 00 00 00 00 00 01 05 01 06 01 07 00 00 00 13 00 00 00 00 00 00 00 14 00 00 00 00 00 00 00
//       Array values:
//            src: 0102 0103 0104 0105 0106 0107 0108 0109 010A 010B 010C 010D 010E
//           dest: 0100000000000011 0000000701060105 0000000000000013 0000000000000014
//
//    Buffer.BlockCopy(src, 16, dest, 22, 5)
//       Array values as Bytes:
//            src: 02 01 03 01 04 01 05 01 06 01 07 01 08 01 09 01 0A 01 0B 01 0C 01 0D 01 0E 01
//           dest: 11 00 00 00 00 00 00 01 05 01 06 01 07 00 00 00 13 00 00 00 00 00 0A 01 0B 01 0C 00 00 00 00 00
//       Array values:
//            src: 0102 0103 0104 0105 0106 0107 0108 0109 010A 010B 010C 010D 010E
//           dest: 0100000000000011 0000000701060105 010A000000000013 00000000000C010B
//
//    Buffer.BlockCopy(src, 4, src, 5, 7)
//       Array values as Bytes:
//            src: 02 01 03 01 04 04 01 05 01 06 01 07 08 01 09 01 0A 01 0B 01 0C 01 0D 01 0E 01
//           dest: 11 00 00 00 00 00 00 01 05 01 06 01 07 00 00 00 13 00 00 00 00 00 0A 01 0B 01 0C 00 00 00 00 00
//       Array values:
//            src: 0102 0103 0404 0501 0601 0701 0108 0109 010A 010B 010C 010D 010E
//           dest: 0100000000000011 0000000701060105 010A000000000013 00000000000C010B
//
//    Buffer.BlockCopy(src, 16, src, 15, 7)
//       Array values as Bytes:
//            src: 02 01 03 01 04 04 01 05 01 06 01 07 08 01 09 0A 01 0B 01 0C 01 0D 0D 01 0E 01
//           dest: 11 00 00 00 00 00 00 01 05 01 06 01 07 00 00 00 13 00 00 00 00 00 0A 01 0B 01 0C 00 00 00 00 00
//       Array values:
//            src: 0102 0103 0404 0501 0601 0701 0108 0A09 0B01 0C01 0D01 010D 010E
//           dest: 0100000000000011 0000000701060105 010A000000000013 00000000000C010B

Module Example
    ' Display the individual bytes in the array in hexadecimal.
    Sub DisplayArray(arr As Array, name As String)
        Console.Write("{0,11}:", name)
        For ctr As Integer = 0 to arr.Length - 1
            Dim bytes() As Byte = BitConverter.GetBytes(arr(ctr))
            For Each byteValue As Byte In bytes
               Console.Write(" {0:X2}", byteValue)
            Next
        Next
        Console.WriteLine()
    End Sub

    ' Display the individual array element values in hexadecimal.
    Sub DisplayArrayValues(arr As Array, name As String)
       ' Get the length of one element in the array.
       Dim elementLength As Integer = Buffer.ByteLength(arr) / arr.Length
       Dim formatString As String = String.Format(" {{0:X{0}}}", 2 * elementLength)
       Console.Write("{0,11}:", name)
       For ctr As Integer = 0 to arr.Length - 1
         Console.Write(formatString, arr(ctr))
       Next
       Console.WriteLine()  
    End Sub
    
    Sub Main()
       Console.WindowWidth = 120
        ' These are source and destination arrays for BlockCopy.
        Dim src()  As Short = { 258, 259, 260, 261, 262, 263, 264, _
                                 265, 266, 267, 268, 269, 270 }
        Dim dest() As Long = { 17, 18, 19, 20 }

        ' Display the initial value of the arrays in memory.
        Console.WriteLine( "Initial values of arrays:")
        Console.WriteLine("   Array values as Bytes:") 
        DisplayArray(src, "src" )
        DisplayArray(dest, "dest" )
        Console.WriteLine("   Array values:")
        DisplayArrayValues(src, "src")
        DisplayArrayValues(dest, "dest")
        Console.WriteLine()

        ' Copy bytes 5-10 from source to index 7 in destination and display the result.
        Buffer.BlockCopy( src, 5, dest, 7, 6 )
        Console.WriteLine("Buffer.BlockCopy(src, 5, dest, 7, 6 )")
        Console.WriteLine("   Array values as Bytes:")
        DisplayArray(src, "src")
        DisplayArray(dest, "dest")
        Console.WriteLine("   Array values:")
        DisplayArrayValues(src, "src")
        DisplayArrayValues(dest, "dest")
        Console.WriteLine()
        
        ' Copy bytes 16-20 from source to index 22 in destination and display the result. 
        Buffer.BlockCopy( src, 16, dest, 22, 5 )
        Console.WriteLine("Buffer.BlockCopy(src, 16, dest, 22, 5)")
        Console.WriteLine("   Array values as Bytes:")
        DisplayArray(src, "src")
        DisplayArray(dest, "dest")
        Console.WriteLine("   Array values:")
        DisplayArrayValues(src, "src")
        DisplayArrayValues(dest, "dest")
        Console.WriteLine()
         
        ' Copy overlapping range of bytes 4-10 to index 5 in source.
        Buffer.BlockCopy( src, 4, src, 5, 7 )
        Console.WriteLine("Buffer.BlockCopy( src, 4, src, 5, 7)")
        Console.WriteLine("   Array values as Bytes:")
        DisplayArray(src, "src")
        DisplayArray(dest, "dest")
        Console.WriteLine("   Array values:")
        DisplayArrayValues(src, "src")
        DisplayArrayValues(dest, "dest")
        Console.WriteLine()
        
        ' Copy overlapping range of bytes 16-22 to index 15 in source. 
        Buffer.BlockCopy(src, 16, src, 15, 7)
        Console.WriteLine("Buffer.BlockCopy( src, 16, src, 15, 7)")
        Console.WriteLine("   Array values as Bytes:")
        DisplayArray(src, "src")
        DisplayArray(dest, "dest")
        Console.WriteLine("   Array values:")
        DisplayArrayValues(src, "src")
        DisplayArrayValues(dest, "dest")
    End Sub 
End Module 
' This example displays the following output:
'    Initial values of arrays:
'       Array values as Bytes:
'            src: 02 01 03 01 04 01 05 01 06 01 07 01 08 01 09 01 0A 01 0B 01 0C 01 0D 01 0E 01
'           dest: 11 00 00 00 00 00 00 00 12 00 00 00 00 00 00 00 13 00 00 00 00 00 00 00 14 00 00 00 00 00 00 00
'       Array values:
'            src: 0102 0103 0104 0105 0106 0107 0108 0109 010A 010B 010C 010D 010E
'           dest: 0000000000000011 0000000000000012 0000000000000013 0000000000000014
'    
'    Buffer.BlockCopy(src, 5, dest, 7, 6 )
'       Array values as Bytes:
'            src: 02 01 03 01 04 01 05 01 06 01 07 01 08 01 09 01 0A 01 0B 01 0C 01 0D 01 0E 01
'           dest: 11 00 00 00 00 00 00 01 05 01 06 01 07 00 00 00 13 00 00 00 00 00 00 00 14 00 00 00 00 00 00 00
'       Array values:
'            src: 0102 0103 0104 0105 0106 0107 0108 0109 010A 010B 010C 010D 010E
'           dest: 0100000000000011 0000000701060105 0000000000000013 0000000000000014
'    
'    Buffer.BlockCopy(src, 16, dest, 22, 5)
'       Array values as Bytes:
'            src: 02 01 03 01 04 01 05 01 06 01 07 01 08 01 09 01 0A 01 0B 01 0C 01 0D 01 0E 01
'           dest: 11 00 00 00 00 00 00 01 05 01 06 01 07 00 00 00 13 00 00 00 00 00 0A 01 0B 01 0C 00 00 00 00 00
'       Array values:
'            src: 0102 0103 0104 0105 0106 0107 0108 0109 010A 010B 010C 010D 010E
'           dest: 0100000000000011 0000000701060105 010A000000000013 00000000000C010B
'    
'    Buffer.BlockCopy( src, 4, src, 5, 7)
'       Array values as Bytes:
'            src: 02 01 03 01 04 04 01 05 01 06 01 07 08 01 09 01 0A 01 0B 01 0C 01 0D 01 0E 01
'           dest: 11 00 00 00 00 00 00 01 05 01 06 01 07 00 00 00 13 00 00 00 00 00 0A 01 0B 01 0C 00 00 00 00 00
'       Array values:
'            src: 0102 0103 0404 0501 0601 0701 0108 0109 010A 010B 010C 010D 010E
'           dest: 0100000000000011 0000000701060105 010A000000000013 00000000000C010B
'    
'    Buffer.BlockCopy( src, 16, src, 15, 7)
'       Array values as Bytes:
'            src: 02 01 03 01 04 04 01 05 01 06 01 07 08 01 09 0A 01 0B 01 0C 01 0D 0D 01 0E 01
'           dest: 11 00 00 00 00 00 00 01 05 01 06 01 07 00 00 00 13 00 00 00 00 00 0A 01 0B 01 0C 00 00 00 00 00
'       Array values:
'            src: 0102 0103 0404 0501 0601 0701 0108 0A09 0B01 0C01 0D01 010D 010E
'           dest: 0100000000000011 0000000701060105 010A000000000013 00000000000C010B

注解

此方法将 count 字节从 src从开始 srcOffset复制到 dst，从 dstOffset开始。和 dstOffset 都是srcOffset从零开始的;也就是说，每个缓冲区中的第一个字节位于位置 0，而不是位置 1。

方法 BlockCopy 使用内存中的偏移量（而不是索引或数组上限和下限）编程构造来访问参数数组中的 src 字节。例如，如果在应用程序的编程语言中声明了一个 Int32 从零开始的下限为 -50 的数组，然后将数组和偏移量 5 传递给 BlockCopy 方法，则该方法将访问的第一个数组元素是数组的第二个元素，该元素位于索引 -49。此外，首先访问数组元素 -49 的哪个字节取决于正在执行应用程序的计算机的字节数。

顾名思义， BlockCopy 该方法将字节块作为一个整体复制，而不是一次复制一个字节。因此，如果 src 和 dst 引用相同的数组，并且范围从 + countsrcOffset-1 与 - dstOffset + count 1 之间的范围重叠，则重叠字节的值在复制到目标之前不会被覆盖。在以下示例中，名为 arr 的数组中字节 0-16 的值将复制到字节 12-28。尽管存在重叠范围，但源字节的值仍会成功复制。

const int INT_SIZE = 4;
array<Int32>^ arr = gcnew array<Int32> { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 };
Buffer::BlockCopy(arr, 0 * INT_SIZE, arr, 3 * INT_SIZE, 4 * INT_SIZE);
for each (int value in arr)
   Console::Write("{0}  ", value);
// The example displays the following output:
//       2  4  6  2  4  6  8  16  18  20

const int INT_SIZE = 4;
int[] arr = { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 };
Buffer.BlockCopy(arr, 0 * INT_SIZE, arr, 3 * INT_SIZE, 4 * INT_SIZE);
foreach (int value in arr)
   Console.Write("{0}  ", value);
// The example displays the following output:
//       2  4  6  2  4  6  8  16  18  20

let intSize = 4
let arr = [| 2; 4; 6; 8; 10; 12; 14; 16; 18; 20 |]
Buffer.BlockCopy(arr, 0 * intSize, arr, 3 * intSize, 4 * intSize)
for value in arr do
    printf $"{value}  "

// The example displays the following output:
//       2  4  6  2  4  6  8  16  18  20

Const INT_SIZE As Integer = 4
Dim arr() As Integer = { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 }
Buffer.BlockCopy(arr, 0 * INT_SIZE, arr, 3 * INT_SIZE, 4 * INT_SIZE)
For Each value As Integer In arr
   Console.Write("{0}  ", value)
Next
' The example displays the following output:
'       2  4  6  2  4  6  8  16  18  20

在以下示例中，名为 arr 的数组中字节 12-28 的值将复制到字节 0-16。同样，尽管存在重叠范围，但源字节的值仍会成功复制。

const int INT_SIZE = 4;
array<Int32>^ arr = gcnew array<Int32> { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 };
Buffer::BlockCopy(arr, 3 * INT_SIZE, arr, 0 * INT_SIZE, 4 * INT_SIZE);
for each (int value in arr)
   Console::Write("{0}  ", value);
// The example displays the following output:
//       8  10  12  14  10  12  14  16  18  20

const int INT_SIZE = 4;
int[] arr = { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 };
Buffer.BlockCopy(arr, 3 * INT_SIZE, arr, 0 * INT_SIZE, 4 * INT_SIZE);
foreach (int value in arr)
   Console.Write("{0}  ", value);
// The example displays the following output:
//       8  10  12  14  10  12  14  16  18  20

let intSize = 4
let arr = [| 2; 4; 6; 8; 10; 12; 14; 16; 18; 20 |]
Buffer.BlockCopy(arr, 3 * intSize, arr, 0 * intSize, 4 * intSize)
for value in arr do
    printf $"{value}  "

// The example displays the following output:
//       8  10  12  14  10  12  14  16  18  20

Const INT_SIZE As Integer = 4
Dim arr() As Integer = { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 }
Buffer.BlockCopy(arr, 3 * INT_SIZE, arr, 0 * INT_SIZE, 4 * INT_SIZE)
For Each value As Integer In arr
   Console.Write("{0}  ", value)
Next
' The example displays the following output:
'       8  10  12  14  10  12  14  16  18  20

适用于

通过

Buffer.BlockCopy(Array, Int32, Array, Int32, Int32) 方法

定义

参数

例外

示例

注解

适用于

其他资源