Compartir vía


Buffer.BlockCopy(Array, Int32, Array, Int32, Int32) Método

Definición

Copia un número especificado de bytes de una matriz de origen a partir de un desplazamiento determinado a una matriz de destino a partir de un desplazamiento determinado.

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 -> unit
Public Shared Sub BlockCopy (src As Array, srcOffset As Integer, dst As Array, dstOffset As Integer, count As Integer)

Parámetros

src
Array

Búfer de origen.

srcOffset
Int32

Desplazamiento de bytes de base cero hacia src.

dst
Array

Búfer de destino.

dstOffset
Int32

Desplazamiento de bytes de base cero hacia dst.

count
Int32

Número de bytes que se van a copiar.

Excepciones

src o dst es null.

src o dst no es una matriz de primitivas.

o bien

El número de bytes de src es menor que srcOffset más count.

o bien

El número de bytes de dst es menor que dstOffset más count.

srcOffset o dstOffset o count es menor que 0.

Ejemplos

En el ejemplo siguiente se copian regiones de matrices mediante el BlockCopy método . Para cada BlockCopy operación, enumera las matrices de origen y destino como una matriz de valores y como una secuencia de bytes. En el ejemplo se muestra la importancia de considerar la endianidad de un sistema al trabajar con el BlockCopy método : Dado que los sistemas Windows son little-endian, los bytes de orden inferior del valor de un tipo de datos primitivo preceden a los bytes de orden superior.

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

Comentarios

Este método copia count bytes de , a partir srcOffsetde src, a dst, a partir de dstOffset. Tanto srcOffset como dstOffset son de base cero; es decir, el primer byte de cada búfer está en la posición 0, no en la posición 1.

El BlockCopy método tiene acceso a los bytes de la src matriz de parámetros mediante desplazamientos en memoria, no construcciones de programación como índices o límites de matriz superior e inferior. Por ejemplo, si en el lenguaje de programación de la aplicación declara una Int32 matriz con un límite inferior de base cero de -50 y, a continuación, pasa la matriz y un desplazamiento de 5 al BlockCopy método, el primer elemento de matriz al que tendrá acceso el método es el segundo elemento de la matriz, que se encuentra en el índice -49. Además, primero se obtiene acceso a qué byte del elemento de matriz -49 depende de la endianidad del equipo que ejecuta la aplicación.

Como su nombre sugiere, el BlockCopy método copia un bloque de bytes en su conjunto, en lugar de copiar un byte a la vez. Por lo tanto, si src y dst hacen referencia a la misma matriz, y el intervalo de + srcOffsetcount -1 se superpone al intervalo decountdstOffset + - 1, los valores de los bytes superpuestos no se sobrescriben antes de que se copien en el destino. En el ejemplo siguiente, los valores de bytes 0-16 de una matriz denominada arr se copian en bytes 12-28. A pesar del intervalo superpuesto, los valores de los bytes de origen se copian correctamente.

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

En el ejemplo siguiente, los valores de bytes 12-28 de una matriz denominada arr se copian en bytes 0-16. De nuevo, a pesar del intervalo superpuesto, los valores de los bytes de origen se copian correctamente.

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

Se aplica a