Buffer.BlockCopy メソッドとは何？わかりやすく解説 Weblio辞書

すべての辞書から再検索する

.NET Framework クラスライブラリリファレンス

索引トップ用語の索引ランキング

Buffer.BlockCopy メソッド

コピー先の配列の指定したオフセット位置を先頭として、コピー元の配列の指定したオフセットから指定数のバイトをコピーします。

名前空間: System
アセンブリ: mscorlib (mscorlib.dll 内)
構文

Visual Basic (宣言)

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

Visual Basic (使用法)

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
)

C++

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
)

JScript

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

パラメータ

src: コピー元のバッファ。

srcOffset: src のバイトオフセット。

dst: コピー先のバッファ。

dstOffset: dst のバイトオフセット。

count: コピーするバイト数。

例外

例外の種類	条件
ArgumentNullException	src または dst が null 参照 (Visual Basic では Nothing) です。
ArgumentException	src や dst はオブジェクトの配列です。値型の配列ではありません。または src の長さが、srcOffset に count を加算した値より小さい値です。または dst の長さが、dstOffset に count を加算した値より小さい値です。
ArgumentOutOfRangeException	srcOffset、dstOffset、または count が 0 未満です。

例外の種類

条件

ArgumentNullException

src または dst が null 参照 (Visual Basic では Nothing) です。

ArgumentException

src や dst はオブジェクトの配列です。値型の配列ではありません。

または

src の長さが、srcOffset に count を加算した値より小さい値です。

または

dst の長さが、dstOffset に count を加算した値より小さい値です。

ArgumentOutOfRangeException

srcOffset、dstOffset、または count が 0 未満です。

解説

dstOffset を先頭として、src の srcOffset から count バイトを dst にコピーします。

開発者は、BlockCopy メソッドが、インデックスや配列の上限および下限などのプログラミング構造ではなく、オフセットを使用して src パラメータの配列にアクセスすることに留意する必要があります。たとえば、使用するアプリケーションのプログラミング言語で、インデックスが 0 から始まり下限が -50 である Int32 配列を宣言し、この配列と 5 のオフセットを BlockCopy メソッドに渡した場合、メソッドがアクセスする最初の配列要素は、-49 のインデックス位置にある配列の 2 番目の要素です。さらに、最初にアクセスされる配列要素 -49 のバイトは、アプリケーションを実行しているコンピュータのエンディアンによって異なります。

使用例

BlockCopy メソッドを使用して、配列の領域をコピーするコード例を次に示します。

Visual Basic

' 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
*/

C++

// 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
*/

プラットフォーム

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

開発プラットフォームの中には、.NET Framework によってサポートされていないバージョンがあります。サポートされているバージョンについては、「システム要件」を参照してください。

バージョン情報

.NET Framework
サポート対象 : 2.0、1.1、1.0
.NET Compact Framework
サポート対象 : 2.0、1.0

参照

関連項目
Buffer クラス
Buffer メンバ
System 名前空間

このページでは「.NET Framework クラスライブラリリファレンス」からBuffer.BlockCopy メソッドを検索した結果を表示しています。
Weblioに収録されているすべての辞書からBuffer.BlockCopy メソッドを検索する場合は、下記のリンクをクリックしてください。

全ての辞書からBuffer.BlockCopy メソッドを検索

>> 「Buffer.BlockCopy メソッド」を含む用語の索引
Buffer.BlockCopy メソッドのページへのリンク

Buffer.BlockCopy メソッドとは？わかりやすく解説

Buffer.BlockCopy メソッド

「Buffer.BlockCopy メソッド」の関連用語


	© 2025 Microsoft.All rights reserved.

Buffer.BlockCopy メソッドとは？ わかりやすく解説

Buffer.BlockCopy メソッド

急上昇のことば

「Buffer.BlockCopy メソッド」の関連用語

Buffer.BlockCopy メソッドとは？わかりやすく解説