Buffer.BlockCopy(Array, Int32, Array, Int32, Int32) 方法
定義
重要
部分資訊涉及發行前產品，在發行之前可能會有大幅修改。 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 -> unitPublic 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
要複製的位元組數。
例外狀況
src 或 dst 為 null。
src 或 dst 不是一組原元。
-或-
該位 src 元組數小於 srcOffset 正數 count。
-或-
該位 dst 元組數小於 dstOffset 正數 count。
srcOffset， ， dstOffset， count 小於 0。
範例
以下範例透過以下 BlockCopy 方法複製陣列區域。 對於每個 BlockCopy 操作，它會將來源與目的陣列列為一個值陣列，也以位元組序列的形式列出。 此範例說明了在使用 BlockCopy 方法時，考慮系統端序的重要性：由於Windows系統是小端序，原始資料型別值的低階位元組會先於高階位元組。
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
備註
此方法從 countsrc，從 ，從 srcOffset，複製到 dst，從 dstOffset開始。 兩者srcOffset皆dstOffset為零基;也就是說，每個緩衝區的第一個位元組位於位置 0，而非位置 1。
此 BlockCopy 方法透過記憶體偏移量存取參數陣列中的 src 位元組，而非透過索引或陣列上下界等程式結構。 例如，如果你在應用程式的程式語言中宣告一個 Int32 陣列，下界為零為基礎，然後將該陣列和偏移量 5 傳給該 BlockCopy 方法，該方法將存取的第一個陣列元素就是陣列的第二個元素，該元素的索引為 -49。 此外，先存取哪個陣列元素 -49 位元組，取決於執行你應用程式的電腦的端序。
顧名思義，此 BlockCopy 方法是將整個位元組區塊複製，而非一次複製一個位元組。 因此，若 src 與 dst 參考相同陣列，且 從 -1 的srcOffset + count範圍與 -1 的範圍dstOffset + count重疊，則重疊位元組的值在複製至目的地前不會被覆寫。 以下範例中，陣列中位 arr 元組 0-16 的值被複製到 12-28 位元組。 儘管範圍重疊，來源位元組的值仍能成功複製。
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;
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
