Understanding the System.Buffer class

Introduction:

Before we try out something with Buffer class lets understand Buffer class and its Members. The first question that comes to mind is how they are different from the Array class and how they work when compared to the Array class. This article is basically to clear the above questions and understand how the Buffer class works.

The word Buffer itself says that it works on direct Memory. In .NET it’s basically a manipulation of unmanaged memory represented as arrays of bytes. So lets take an example of a program where we will copy one array data into another using Array class as first example and compare it with Buffer class example.

In System.Array class we have the Copy() Member to copy from one array to another.

Lets take an example with a array of 5 elements Myarr1[5] initialized with data 1,2,3,4,5 and another array of 10 elements Myarr2[10] with data 0,0,0,0,0,6,7,8,9,10.

In arrays the length means the number of elements in array. In our example Myarr1 has 5 elements so the array length is 5. And Myarr2 has 10 elements so the array length is 10.

The Array class has the Copy() method which copies one arrays content into another. It Copies a range of elements from an Array starting at the specified source index and pastes them to another Array starting at the specified destination index. So the Copy() method takes five parameters .They are source array , source index, destination array , destination index, number of elements to copy.

Note: I am taking array index starting from 1 for better understanding in examples

Before Array.Copy() operation:

After Array.Copy() operation:

Here is the program for using Array.Copy():

namespace ConsoleApplication1
{
      class Array1
      {
            staticvoid Main(string[] args)
            {
                 
            int[] myarr1 = newint[5] {1,2,3,4,5};
            int[] myarr2=newint[10] {0,0,0,0,0,6,7,8,9,10};
           
            Console.Write("Before Array copy operation\n");
            Console.Write("Myarr1 and Byte Length{0}\n",myarr1.Length);
            foreach(int i in myarr1)
                  Console.Write("{0} \t",i);
            Console.WriteLine("\nMyarr2 and Byte Length:{0} \n",myarr2.Length);

            foreach(int i in myarr2)
                  Console.Write("{0} \t",i);

            //here we are copying index to index as data
            Array.Copy(myarr1,0,myarr2,0,5);
           
            Console.Write("After Array copy operation\n");
            Console.Write("Myarr1 :\n");
            foreach(int i in myarr1)
                  Console.Write("{0} \t",i);
            Console.WriteLine("\nMyarr2: \n");
            foreach(int i in myarr2)
                  Console.Write("{0} \t",i);
                  Console.ReadLine();
            }
      }
}

Output:

Before Array Copy operation
Myarr1 and Byte Length :5
1       2       3       4       5
Myarr2 and Byte Length:10
0       0       0       0       0       6       7       8       9       10
After Array Copy operation
Myarr1 :
1       2       3       4       5
Myarr2:
1       2       3       4       5       6       7       8       9       10

Now we will see same thing can be done using System.Buffer class using BlockCopy() method. But its not index to index copy in Buffer class. It’s from offset to offset. So it copies a specified number of bytes from a source array starting at a particular offset to a destination array starting at a particular offset. Since we have taken integer arrays as example and we know int occupies 4bytes. So offset values will be addition of 4bytes from starting offset value.

In System.Buffer class we have BlockCopy() Member to copy from one array to another.Lets take an example with a array of 5 elements Myarr1[5] initialized with data 1,2,3,4,5 and another array of 10 elements Myarr2[10] with data 0,0,0,0,0,6,7,8,9,10.

In Buffer class the length means number of byte length in array. In our example Myarr1 has 5 elements so byte length is 5 (elements) x 4 (bytes of int)= 20 bytes. And for Myarr2 has 10 elements so the byte length is 10 (elements) x 4 (bytes of int) = 40 bytes.

You can get the byte length of array by using Buffer.ByteLength(Myarr1).

The Buffer class has BlockCopy() method which copies one array content into another. It Copies a range of elements from an Array starting at the specified source start offset value and copies them to another Array starting at the specified destination offset value. So BlockCopy() method takes five parameters .They are source array , source offset value , destination array , destination offset value, number of bytes to copy ( in our example we need to copy 5 elements then 5 x 4 = 20 bytes is the number of bytes to copy).

Before Buffer.BulkCopy() operation:

AfterBuffer.BulkCopy() operation

 Here is the program for using Buffer.BlockCopy():

using System;

namespace ConsoleApplication1
{
        class buffer1
        {
               staticvoid Main(string[] args)
               {
                      
               int[] myarr1 = newint[5] {1,2,3,4,5};
               int[] myarr2=newint[10] {0,0,0,0,0,6,7,8,9,10};
           
               Console.Write("Before Block copy operation\n");
               Console.Write("Myarr1 and Byte Length :{0}\n",Buffer.ByteLength(myarr1));
              
               foreach(int i in myarr1)
                       Console.Write("{0} \t",i);

               Console.WriteLine("\nMyarr2 and Byte Length:{0} \n",Buffer.ByteLength(myarr2));

               foreach(int i in myarr2)
                       Console.Write("{0} \t",i);
              
               //here we are copying offset to offet as bytes
               Buffer.BlockCopy(myarr1,0,myarr2,0,20);
               Console.Write("After Block copy operation\n");
               Console.Write("Myarr1 :\n");
                foreach(int i in myarr1)
                       Console.Write("{0} \t",i);
               Console.WriteLine("\nMyarr2: \n");
               foreach(int i in myarr2)
                       Console.Write("{0} \t",i);

               Console.ReadLine();
               }
        }
}

Output:

Before Block Copy operation
Myarr1 and Byte Length :20
1       2       3       4       5
Myarr2 and Byte Length:40
0       0       0       0       0       6       7       8       9       10
After Block Copy operation
Myarr1 :
1       2       3       4       5
Myarr2:
1       2       3       4       5       6       7       8       9       10

If you observe the both example they do give same result but the way they operate is completely different.

In example 1 we used Array.Copy(myarr1,0,myarr2,0,5);--> here 5 means number array elements to copy
In example 2 we used Buffer.BlockCopy(myarr1,0,myarr2,0,20);--> here 20 means number of bytes to copy

So in our example 5 elements of int occupies 20 bytes.

Further reading:

1. Microsoft:  More information on .NET technologies

This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.

A list of licenses authors might use can be found here