Buffer.BlockCopy-Methode

Artikel
08/20/2007

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

Namespace: System
Assembly: mscorlib (in mscorlib.dll)

Syntax

'Declaration
Public Shared Sub BlockCopy ( _
    src As Array, _
    srcOffset As Integer, _
    dst As Array, _
    dstOffset As Integer, _
    count As Integer _
)
'Usage
Dim src As Array
Dim srcOffset As Integer
Dim dst As Array
Dim dstOffset As Integer
Dim count As Integer

Buffer.BlockCopy(src, srcOffset, dst, dstOffset, count)

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
)

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

public static function BlockCopy (
    src : Array, 
    srcOffset : int, 
    dst : Array, 
    dstOffset : int, 
    count : int
)

Parameter

src
Der Quellpuffer.

srcOffset
Der Byteoffset in src.

dst
Der Zielpuffer.

dstOffset
Der Byteoffset in dst.

count
Die Anzahl der zu kopierenden Bytes.

Ausnahmen

Ausnahmetyp	Bedingung
ArgumentNullException	src oder dst ist NULL (Nothing in Visual Basic).
ArgumentException	src oder dst ist ein Objektarray, kein Werttyparray. – oder – Die Länge von src ist kleiner als die Summe aus srcOffset und count. – oder – Die Länge von dst ist kleiner als die Summe aus dstOffset und count.
ArgumentOutOfRangeException	srcOffset, dstOffset oder count ist kleiner als 0.

ArgumentNullException

src oder dst ist NULL (Nothing in Visual Basic).

ArgumentException

src oder dst ist ein Objektarray, kein Werttyparray.

– oder –

Die Länge von src ist kleiner als die Summe aus srcOffset und count.

– oder –

Die Länge von dst ist kleiner als die Summe aus dstOffset und count.

ArgumentOutOfRangeException

srcOffset, dstOffset oder count ist kleiner als 0.

Hinweise

Kopiert count Bytes von src, beginnend bei srcOffset, nach dst, beginnend bei dstOffset.

Entwickler müssen beachten, dass die BlockCopy-Methode mithilfe von Offsets auf das src-Parameterarray zugreift, und dass keine Konstrukte wie z. B. Indizes oder obere und untere Arraybegrenzungen programmiert werden dürfen. Wenn Sie z. B. in der Programmiersprache der Anwendung ein Int32-Array mit einer nullbasierten unteren Begrenzung von -50 deklarieren und anschließend das Array und einen Offset von 5 an die BlockCopy-Methode übergeben, handelt es sich beim ersten Arrayelement, auf das die Methode zugreift, um das zweite Element des Arrays, das sich am Index -49 befindet. Auf welches Byte von Arrayelement -49 zuerst zugegriffen wird, hängt weiterhin von der Endian-Reihenfolge des Computers ab, der die Anwendung ausführt.

Beispiel

Im folgenden Codebeispiel werden Bereiche von Arrays mit der BlockCopy-Methode kopiert.

' Example of the Buffer.BlockCopy method.
Imports System
Imports Microsoft.VisualBasic

Module BlockCopyDemo

    ' Display the array contents in hexadecimal.
    Sub DisplayArray( arr As Array, name As String )

        ' Get the array element width; format the formatting string.
        Dim loopX     As Integer
        Dim elemWidth As Integer = _
            Buffer.ByteLength( arr ) / arr.Length
        Dim format    As String = _
            String.Format( " {{0:X{0}}}", 2 * elemWidth )

        ' Display the array elements from right to left.
        Console.Write( "{0,5}:", name )
        For loopX = arr.Length - 1 to 0 Step -1
            Console.Write( format, arr( loopX ) )
        Next loopX
        Console.WriteLine( )
    End Sub

    Sub Main( )

        ' 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 }

        Console.WriteLine( "This example of the " & vbCrLf & _
            "Buffer.BlockCopy( Array, Integer, Array, " & _
            "Integer, Integer ) " & vbCrLf & "method generates " & _
            "the following output." & vbCrLf & "Note: The " & _
            "arrays are displayed from right to left." & vbCrLf )
        Console.WriteLine( "  Initial values of arrays:" & vbCrLf )

        ' Display the values of the arrays.
        DisplayArray( src, "src" )
        DisplayArray( dest, "dest" )

        ' Copy two regions of source array to destination array,
        ' and two overlapped copies from source to source.
        Console.WriteLine( vbCrLf & _
            "  Call these methods: " & vbCrLf & vbCrLf & _
            " Buffer.BlockCopy( src, 5, dest, 7, 6 )," & vbCrLf & _
            " Buffer.BlockCopy( src, 16, dest, 22, 5 )," & vbCrLf & _
            "  (these overlap source and destination)" & vbCrLf & _
            " Buffer.BlockCopy( src, 4, src, 5, 7 )," & vbCrLf & _
            " Buffer.BlockCopy( src, 16, src, 15, 7 )." & vbCrLf )
        Console.WriteLine( "  Final values of arrays:" & vbCrLf )

        Buffer.BlockCopy( src, 5, dest, 7, 6 )
        Buffer.BlockCopy( src, 16, dest, 22, 5 )
        Buffer.BlockCopy( src, 4, src, 5, 7 )
        Buffer.BlockCopy( src, 16, src, 15, 7 )

        ' Display the arrays again.
        DisplayArray( src, "src" )
        DisplayArray( dest, "dest" )

    End Sub 
End Module 

' This example of the
' Buffer.BlockCopy( Array, Integer, Array, Integer, Integer )
' method generates the following output.
' Note: The arrays are displayed from right to left.
' 
'   Initial values of arrays:
' 
'   src: 010E 010D 010C 010B 010A 0109 0108 0107 0106 0105 0104 0103 0102
'  dest: 0000000000000014 0000000000000013 0000000000000012 0000000000000011
' 
'   Call these methods:
' 
'  Buffer.BlockCopy( src, 5, dest, 7, 6 ),
'  Buffer.BlockCopy( src, 16, dest, 22, 5 ),
'   (these overlap source and destination)
'  Buffer.BlockCopy( src, 4, src, 5, 7 ),
'  Buffer.BlockCopy( src, 16, src, 15, 7 ).
' 
'   Final values of arrays:
' 
'   src: 010E 010D 0D01 0C01 0B01 0A09 0108 0701 0601 0501 0404 0103 0102
'  dest: 00000000000C010B 010A000000000013 0000000701060105 0100000000000011

// Example of the Buffer.BlockCopy method.
using System;

class BlockCopyDemo
{
    // Display the array contents in hexadecimal.
    public static void DisplayArray( Array arr, string name )
    {
        // Get the array element width; format the formatting string.
        int elemWidth = Buffer.ByteLength( arr ) / arr.Length;
        string format = String.Format( " {{0:X{0}}}", 2 * elemWidth );

        // Display the array elements from right to left.
        Console.Write( "{0,5}:", name );
        for( int loopX = arr.Length - 1; loopX >= 0; loopX-- )
            Console.Write( format, arr.GetValue( loopX ) );
        Console.WriteLine( );
    }

    public static void Main( )
    {
        // These are 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 };

        Console.WriteLine( "This example of the \n" +
            "Buffer.BlockCopy( Array, int, Array, int, " +
            "int ) \nmethod generates the following output.\n" +
            "Note: The arrays are displayed from right to left.\n" );
        Console.WriteLine( "  Initial values of arrays:\r\n" );

        // Display the values of the arrays.
        DisplayArray( src, "src" );
        DisplayArray( dest, "dest" );

        // Copy two regions of source array to destination array,
        // and two overlapped copies from source to source.
        Console.WriteLine( "\n  Call these methods: \n\n" +
            " Buffer.BlockCopy( src, 5, dest, 7, 6 ),\n" +
            " Buffer.BlockCopy( src, 16, dest, 22, 5 ),\n" +
            "  (these overlap source and destination)\n" +
            " Buffer.BlockCopy( src, 4, src, 5, 7 ),\n" +
            " Buffer.BlockCopy( src, 16, src, 15, 7 ).\n" );
        Console.WriteLine( "  Final values of arrays:\n" );

        Buffer.BlockCopy( src, 5, dest, 7, 6 );
        Buffer.BlockCopy( src, 16, dest, 22, 5 );
        Buffer.BlockCopy( src, 4, src, 5, 7 );
        Buffer.BlockCopy( src, 16, src, 15, 7 );

        // Display the arrays again.
        DisplayArray( src, "src" );
        DisplayArray( dest, "dest" );
    }
}

/*
This example of the
Buffer.BlockCopy( Array, int, Array, int, int )
method generates the following output.
Note: The arrays are displayed from right to left.

  Initial values of arrays:

  src: 010E 010D 010C 010B 010A 0109 0108 0107 0106 0105 0104 0103 0102
 dest: 0000000000000014 0000000000000013 0000000000000012 0000000000000011

  Call these methods:

 Buffer.BlockCopy( src, 5, dest, 7, 6 ),
 Buffer.BlockCopy( src, 16, dest, 22, 5 ),
  (these overlap source and destination)
 Buffer.BlockCopy( src, 4, src, 5, 7 ),
 Buffer.BlockCopy( src, 16, src, 15, 7 ).

  Final values of arrays:

  src: 010E 010D 0D01 0C01 0B01 0A09 0108 0701 0601 0501 0404 0103 0102
 dest: 00000000000C010B 010A000000000013 0000000701060105 0100000000000011
*/

// Example of the Buffer::BlockCopy method.
using namespace System;

// Display the array contents in hexadecimal.
void DisplayArray( Array^ arr, String^ name )
{
   
   // Get the array element width; format the formatting string.
   int elemWidth = Buffer::ByteLength( arr ) / arr->Length;
   String^ format = String::Format( " {{0:X{0}}}", 2 * elemWidth );
   
   // Display the array elements from right to left.
   Console::Write( "{0,5}:", name );
   for ( int loopX = arr->Length - 1; loopX >= 0; loopX-- )
      Console::Write( format, arr->GetValue( loopX ) );
   Console::WriteLine();
}

int main()
{
   
   // These are source and destination arrays for BlockCopy.
   array<short>^src = {258,259,260,261,262,263,264,265,266,267,268,269,270};
   array<__int64>^dest = {17,18,19,20};
   Console::WriteLine( "This example of the \n"
   "Buffer::BlockCopy( Array*, int, Array*, int, "
   "int ) \nmethod generates the following output.\n"
   "Note: The arrays are displayed from right to left.\n" );
   Console::WriteLine( "  Initial values of arrays:\r\n" );
   
   // Display the values of the arrays.
   DisplayArray( src, "src" );
   DisplayArray( dest, "dest" );
   
   // Copy two regions of source array to destination array,
   // and two overlapped copies from source to source.
   Console::WriteLine( "\n  Call these methods: \n\n"
   " Buffer::BlockCopy( src, 5, dest, 7, 6 ),\n"
   " Buffer::BlockCopy( src, 16, dest, 22, 5 ),\n"
   "  (these overlap source and destination)\n"
   " Buffer::BlockCopy( src, 4, src, 5, 7 ),\n"
   " Buffer::BlockCopy( src, 16, src, 15, 7 ).\n" );
   Console::WriteLine( "  Final values of arrays:\n" );
   Buffer::BlockCopy( src, 5, dest, 7, 6 );
   Buffer::BlockCopy( src, 16, dest, 22, 5 );
   Buffer::BlockCopy( src, 4, src, 5, 7 );
   Buffer::BlockCopy( src, 16, src, 15, 7 );
   
   // Display the arrays again.
   DisplayArray( src, "src" );
   DisplayArray( dest, "dest" );
}

/*
This example of the
Buffer::BlockCopy( Array*, int, Array*, int, int )
method generates the following output.
Note: The arrays are displayed from right to left.

  Initial values of arrays:

  src: 010E 010D 010C 010B 010A 0109 0108 0107 0106 0105 0104 0103 0102
 dest: 0000000000000014 0000000000000013 0000000000000012 0000000000000011

  Call these methods:

 Buffer::BlockCopy( src, 5, dest, 7, 6 ),
 Buffer::BlockCopy( src, 16, dest, 22, 5 ),
  (these overlap source and destination)
 Buffer::BlockCopy( src, 4, src, 5, 7 ),
 Buffer::BlockCopy( src, 16, src, 15, 7 ).

  Final values of arrays:

  src: 010E 010D 0D01 0C01 0B01 0A09 0108 0701 0601 0501 0404 0103 0102
 dest: 00000000000C010B 010A000000000013 0000000701060105 0100000000000011
*/

// Example of the Buffer.BlockCopy method.
import System.*;

class BlockCopyDemo
{
    // Display the array contents in hexadecimal.
    public static void DisplayArray(Array arr, String name)
    {
        // Get the array element width; format the formatting string.
        int elemWidth = Buffer.ByteLength(arr) / arr.get_Length();
        String format = String.Format(" {{0:X{0}}}", (Int32)(2 * elemWidth));

        // Display the array elements from right to left.
        Console.Write("{0,5}:", name);
        for (int loopX = arr.get_Length() - 1; loopX >= 0; loopX--) {
            Console.Write(format, arr.GetValue(loopX));
        }
        Console.WriteLine();
    } //DisplayArray

    public static void main(String[] args)
    {
        // These are 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 };

        Console.WriteLine(("This example of the \n"  
            + "Buffer.BlockCopy( Array, int, Array, int, int ) \n"
            + "method generates the following output.\n" 
            + "Note: The arrays are displayed from right to left.\n"));
        Console.WriteLine("  Initial values of arrays:\r\n");

        // Display the values of the arrays.
        DisplayArray(src, "src");
        DisplayArray(dest, "dest");

        // Copy two regions of source array to destination array,
        // and two overlapped copies from source to source.
        Console.WriteLine("\n  Call these methods: \n\n"  
            + " Buffer.BlockCopy( src, 5, dest, 7, 6 ),\n" 
            + " Buffer.BlockCopy( src, 16, dest, 22, 5 ),\n"  
            + "  (these overlap source and destination)\n"  
            + " Buffer.BlockCopy( src, 4, src, 5, 7 ),\n"  
            + " Buffer.BlockCopy( src, 16, src, 15, 7 ).\n");
        Console.WriteLine("  Final values of arrays:\n");
        Buffer.BlockCopy(src, 5, dest, 7, 6);
        Buffer.BlockCopy(src, 16, dest, 22, 5);
        Buffer.BlockCopy(src, 4, src, 5, 7);
        Buffer.BlockCopy(src, 16, src, 15, 7);

        // Display the arrays again.
        DisplayArray(src, "src");
        DisplayArray(dest, "dest");
    } //main
} //BlockCopyDemo

/*
This example of the
Buffer.BlockCopy( Array, int, Array, int, int )
method generates the following output.
Note: The arrays are displayed from right to left.

  Initial values of arrays:

  src: 010E 010D 010C 010B 010A 0109 0108 0107 0106 0105 0104 0103 0102
 dest: 0000000000000014 0000000000000013 0000000000000012 0000000000000011

  Call these methods:

 Buffer.BlockCopy( src, 5, dest, 7, 6 ),
 Buffer.BlockCopy( src, 16, dest, 22, 5 ),
  (these overlap source and destination)
 Buffer.BlockCopy( src, 4, src, 5, 7 ),
 Buffer.BlockCopy( src, 16, src, 15, 7 ).

  Final values of arrays:

  src: 010E 010D 0D01 0C01 0B01 0A09 0108 0701 0601 0501 0404 0103 0102
 dest: 00000000000C010B 010A000000000013 0000000701060105 0100000000000011
*/

Plattformen

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Buffer.BlockCopy-Methode

Syntax

Parameter

Ausnahmen

Hinweise

Beispiel

Plattformen

Versionsinformationen

.NET Framework

.NET Compact Framework

Siehe auch

Referenz

Zusätzliche Ressourcen