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

.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)
C#
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
)
J#
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 未満です。

解説解説

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
C#
// 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
*/
J#
// 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 名前空間

英和和英テキスト翻訳

英語⇒日本語日本語⇒英語

辞書ショートカット

カテゴリ一覧

全て

＋ ビジネス

＋ 業界用語

＋ コンピュータ

＋ 電車

＋ 自動車・バイク

＋ 船

＋ 工学

＋ 建築・不動産

＋ 学問

＋ 文化

＋ 生活

＋ ヘルスケア

＋ 趣味

＋ スポーツ

＋ 生物

＋ 食品

＋ 人名

＋ 方言

＋ 辞書・百科事典

すべての辞書の索引

あいうえお
かきくけこ
さしすせそ
たちつてと
なにぬねの
はひふへほ
まみむめも
やゆよ
らりるれろ
わをん
がぎぐげご
ざじずぜぞ
だぢづでど
ばびぶべぼ
ぱぴぷぺぽ
ＡＢＣＤＥ
ＦＧＨＩＪ
ＫＬＭＮＯ
ＰＱＲＳＴ
ＵＶＷＸＹ
Ｚ
１２３４５
６７８９０
記号

Weblioのサービス

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

1
Buffer クラス
.NET Framework クラス ライブラリ リファレンス
72% |||||

Buffer.BlockCopy メソッドのお隣キーワード

Brushes プロパティ

Brushes メソッド

Brushes メンバ

Brushes.White プロパティ

Brushes.Yellow プロパティ

Brushes.YellowGreen プロパティ

Buffer.BlockCopy メソッド

Buffer.ByteLength メソッド

BufferedGraphics クラス

BufferedGraphics.Dispose メソッド

BufferedGraphics.Graphics プロパティ

BufferedGraphics.Render メソッド

BufferedGraphicsContext クラス

検索ランキング

   

 英語⇒日本語
日本語⇒英語		    


Buffer.BlockCopy メソッドのページの著作権

   
日本マイクロソフト株式会社日本マイクロソフト株式会社
© 2026 Microsoft.All rights reserved.

©2026 GRAS Group, Inc.RSS