Buffer.BlockCopy(Array, Int32, Array, Int32, Int32) Metoda
Definice
Důležité
Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.
Zkopíruje zadaný počet bajtů ze zdrojového pole začínající určitým posunem na cílovou matici počínaje určitým posunem.
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)Parametry
- src
- Array
Zdrojová vyrovnávací paměť.
- srcOffset
- Int32
Posun bajtů založených na nule do src.
- dst
- Array
Cílová vyrovnávací paměť.
- dstOffset
- Int32
Posun bajtů založených na nule do dst.
- count
- Int32
Počet bajtů, které chcete zkopírovat.
Výjimky
src nebo dst je null.
src nebo dst není pole primitiv.
nebo
Počet bajtů je src menší než srcOffset plus count.
nebo
Počet bajtů je dst menší než dstOffset plus count.
srcOffset, dstOffsetnebo count je menší než 0.
Příklady
Následující příklad kopíruje oblasti polí pomocí BlockCopy metody. Pro každou BlockCopy operaci zobrazí seznam zdrojových a cílových polí jako pole hodnot i jako posloupnost bajtů. Příklad znázorňuje důležitost zvážení endianness systému při práci s metodou BlockCopy: Vzhledem k tomu, že systémy Windows jsou malé endian, nižší pořadí bajtů primitivního datového typu předchází bajtům vyššího řádu.
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
Poznámky
Tato metoda kopíruje bajty od count, počínaje src, do srcOffset, od dst.dstOffset Obě srcOffset a dstOffset jsou založené na nule. To znamená, že první bajt v každé vyrovnávací paměti je na pozici 0, nikoli na pozici 1.
Metoda BlockCopy přistupuje k bajtům v src poli parametrů pomocí posunů do paměti, nikoli programovacích konstruktorů, jako jsou indexy nebo horní a dolní hranice pole. Pokud například v programovacím jazyce vaší aplikace deklarujete Int32 matici s dolní mez -50 založenou na nule a pak předáte pole a posun 5 do BlockCopy metody, první prvek pole, ke kterému metoda získá přístup, je druhý prvek pole, který je na indexu -49. To, ke kterému bajtu prvku pole -49 se přistupuje jako první, závisí na endianitě počítače, který spouští vaši aplikaci.
Jak naznačuje jeho název, BlockCopy metoda kopíruje blok bajtů jako celku, nikoli kopírování jednoho bajtu najednou. Proto pokud src a dst odkazuje na stejnou matici a rozsah odsrcOffset + count -1 překrývá oblast oddstOffset + count- 1, hodnoty překrývajících se bajtů se před zkopírováním do cíle nepřepíšou. V následujícím příkladu se hodnoty bajtů 0–16 v matici s názvem arr zkopírují do bajtů 12-28. Navzdory překrývajícímu se rozsahu se hodnoty zdrojových bajtů úspěšně zkopírují.
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
V následujícím příkladu se hodnoty bajtů 12-28 v matici s názvem arr zkopírují do bajtů 0-16. I přes překrývající se oblast se hodnoty zdrojových bajtů úspěšně zkopírují.
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
