Buffer.BlockCopy(Array, Int32, Array, Int32, Int32) Method
Definition
Important
Some information relates to prerelease product that may be substantially modified before it’s released. Microsoft makes no warranties, express or implied, with respect to the information provided here.
Copies a specified number of bytes from a source array starting at a particular offset to a destination array starting at a particular offset.
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)Parameters
- src
- Array
The source buffer.
- srcOffset
- Int32
The zero-based byte offset into src.
- dst
- Array
The destination buffer.
- dstOffset
- Int32
The zero-based byte offset into dst.
- count
- Int32
The number of bytes to copy.
Exceptions
src or dst is null.
src or dst is not an array of primitives.
-or-
The number of bytes in src is less than srcOffset plus count.
-or-
The number of bytes in dst is less than dstOffset plus count.
srcOffset, dstOffset, or count is less than 0.
Examples
The following example copies regions of arrays by using the BlockCopy method. For each BlockCopy operation, it lists the source and destination arrays as both an array of values and as a sequence of bytes. The example illustrates the importance of considering a system's endianness when working with the BlockCopy method: Because Windows systems are little-endian, the lower-order bytes of a primitive data type's value precede the higher-order bytes.
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
Remarks
This method copies count bytes from src, beginning at srcOffset, to dst, beginning at dstOffset. Both srcOffset and dstOffset are zero-based; that is, the first byte in each buffer is at position 0, not position 1.
The BlockCopy method accesses the bytes in the src parameter array using offsets into memory, not programming constructs such as indexes or upper and lower array bounds. For example, if in the programming language of your application you declare an Int32 array with a zero-based lower bound of -50, and then pass the array and an offset of 5 to the BlockCopy method, the first array element the method will access is the second element of the array, which is at index -49. Furthermore, which byte of array element -49 is accessed first depends on the endianness of the computer that is executing your application.
As its name suggests, the BlockCopy method copies a block of bytes as a whole, rather than copying one byte at a time. Therefore, if src and dst reference the same array, and the range from srcOffset + count -1 overlaps the range from dstOffset + count - 1, the values of the overlapping bytes are not overwritten before they are copied to the destination. In the following example, the values of bytes 0-16 in an array named arr are copied to bytes 12-28. Despite the overlapping range, the values of the source bytes are successfully copied.
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
In the following example, the values of bytes 12-28 in an array named arr are copied to bytes 0-16. Again, despite the overlapping range, the values of the source bytes are successfully copied.
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
Applies to
Співпраця з нами на GitHub
Джерело цього вмісту можна знайти на GitHub, де також можна створювати й переглядати запитання та запити на внесення змін. Докладні відомості наведено в нашому посібнику для співавторів.
