Auf Englisch lesen

Freigeben über

Buffer.BlockCopy(Array, Int32, Array, Int32, Int32) Methode

  • Referenz

Definition

Namespace:
System
Assembly:
System.Runtime.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Kopiert eine angegebene Anzahl von Bytes aus einem Quellarray in ein Zielarray, jeweils beginnend bei einem bestimmten Offset.

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

Parameter

src
Array

Der Quellpuffer.

srcOffset
Int32

Der nullbasierte Byteoffset in src.

dst
Array

Der Zielpuffer.

dstOffset
Int32

Der nullbasierte Byteoffset in dst.

count
Int32

Die Anzahl der zu kopierenden Bytes.

Ausnahmen

ArgumentNullException

src oder dst ist null.

ArgumentException

src oder dst ist kein Array primitiver Datentypen.

- oder - Die Anzahl der Bytes in src ist kleiner als srcOffset plus count.

- oder - Die Anzahl der Bytes in dst ist kleiner als dstOffset plus count.

ArgumentOutOfRangeException

srcOffset, dstOffset oder count ist kleiner als 0 (null).

Beispiele

Im folgenden Beispiel werden Bereiche von Arrays mithilfe der BlockCopy Methode kopiert. Für jeden BlockCopy Vorgang werden die Quell- und Zielarrays sowohl als Array mit Werten als auch als Sequenz von Bytes aufgelistet. Das Beispiel veranschaulicht die Wichtigkeit der Betrachtung der Endianität eines Systems beim Arbeiten mit der BlockCopy Methode: Da Windows Systeme wenig endisch sind, liegt der Wert eines Grundtyps vor dem Wert eines primitiven Datentyps vor dem Wert höherer Reihenfolge.

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

Hinweise

Diese Methode kopiert count Bytes von src, beginnend bei srcOffset, bis dst, beginnend bei dstOffset. Beide srcOffset und dstOffset nullbasiert; das heißt, der erste Byte in jedem Puffer befindet sich an Position 0, nicht Position 1.

Die BlockCopy Methode greift auf die Bytes im src Parameterarray mit Offsets in den Arbeitsspeicher zu, nicht programmierungskonstrukte wie Indizes oder obere und untere Arraygrenzen. Wenn Sie beispielsweise in der Programmiersprache Ihrer Anwendung ein Int32 Array mit einer nullbasierten Untergrenze von -50 deklarieren und dann das Array und einen Offset von 5 an die BlockCopy Methode übergeben, ist das erste Arrayelement, auf das die Methode zugreift, das zweite Element des Arrays, das sich im Index -49 befindet. Darüber hinaus hängt das Byte des Arrayelements -49 zuerst von der Endianität des Computers ab, der Ihre Anwendung ausführt.

Wie der Name vorschlägt, kopiert die BlockCopy Methode einen Byteblock als Ganzes, anstatt ein Byte gleichzeitig zu kopieren. Wenn und verweisen Sie daher auf dasselbe Array, und der Bereich voncount srcOffset + -1 überschneidet den Bereich von dstOffset``count + - 1, werden die Werte der überlappenden Bytes nicht überschrieben, bevor sie in das Ziel kopiert werden.src dst Im folgenden Beispiel werden die Werte von Bytes 0-16 in einem Array namens arr in Bytes 12-28 kopiert. Trotz des überlappenden Bereichs werden die Werte der Quellbytes erfolgreich kopiert.

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

Im folgenden Beispiel werden die Werte von Bytes 12-28 in einem Array namens arr 0-16 kopiert. Trotz des überlappenden Bereichs werden die Werte der Quellbytes erfolgreich kopiert.

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

Gilt für