Imports System
Imports System.IO

Public Class BinaryRW

    Shared Sub Main()

        Const upperBound As Integer = 1000

        ' Create random data to write to the stream.
        Dim dataArray(upperBound) As Byte
        Dim randomGenerator As New Random
        randomGenerator.NextBytes(dataArray)

        Dim binWriter As New BinaryWriter(New MemoryStream())

        ' Write the data to the stream.
        Console.WriteLine("Writing the data.")
        binWriter.Write(dataArray, 0, dataArray.Length)

        ' Create the reader using the stream from the writer.
        Dim binReader As New BinaryReader(binWriter.BaseStream)

        ' Set Position to the beginning of the stream.
        binReader.BaseStream.Position = 0

        ' Read and verify the data.
        Dim verifyArray(upperBound) As Byte
        If binReader.Read(verifyArray, 0, dataArray.Length) _
            <> dataArray.Length Then

            Console.WriteLine("Error writing the data.")
            Return
        End If
        For i As Integer =  0 To upperBound
            If verifyArray(i) <> dataArray(i) Then
                Console.WriteLine("Error writing the data.")
                Return
            End If
        Next i
        Console.WriteLine("The data was written and verified.")

    End Sub
End Class

using System;
using System.IO;

class BinaryRW
{
    static void Main()
    {
        const int arrayLength = 1000;

        // Create random data to write to the stream.
        byte[] dataArray = new byte[arrayLength];
        new Random().NextBytes(dataArray);

        BinaryWriter binWriter = new BinaryWriter(new MemoryStream());

        // Write the data to the stream.
        Console.WriteLine("Writing the data.");
        binWriter.Write(dataArray, 0, arrayLength);

        // Create the reader using the stream from the writer.
        BinaryReader binReader = 
            new BinaryReader(binWriter.BaseStream);

        // Set Position to the beginning of the stream.
        binReader.BaseStream.Position = 0;

        // Read and verify the data.
        byte[] verifyArray = new byte[arrayLength];
        if(binReader.Read(verifyArray, 0, arrayLength) != arrayLength)
        {
            Console.WriteLine("Error writing the data.");
            return;
        }
        for(int i = 0; i < arrayLength; i++)
        {
            if(verifyArray[i] != dataArray[i])
            {
                Console.WriteLine("Error writing the data.");
                return;
            }
        }
        Console.WriteLine("The data was written and verified.");
    }
}

using namespace System;
using namespace System::IO;
int main()
{
   const int arrayLength = 1000;

   // Create random data to write to the stream.
   array<Byte>^dataArray = gcnew array<Byte>(arrayLength);
   (gcnew Random)->NextBytes( dataArray );
   BinaryWriter^ binWriter = gcnew BinaryWriter( gcnew MemoryStream );

   // Write the data to the stream.
   Console::WriteLine( "Writing the data." );
   binWriter->Write( dataArray, 0, arrayLength );

   // Create the reader using the stream from the writer.
   BinaryReader^ binReader = gcnew BinaryReader( binWriter->BaseStream );

   // Set Position to the beginning of the stream.
   binReader->BaseStream->Position = 0;

   // Read and verify the data.
   array<Byte>^verifyArray = gcnew array<Byte>(arrayLength);
   if ( binReader->Read( verifyArray, 0, arrayLength ) != arrayLength )
   {
      Console::WriteLine( "Error writing the data." );
      return  -1;
   }

   for ( int i = 0; i < arrayLength; i++ )
   {
      if ( verifyArray[ i ] != dataArray[ i ] )
      {
         Console::WriteLine( "Error writing the data." );
         return  -1;
      }

   }
   Console::WriteLine( "The data was written and verified." );
}

Imports System
Imports System.IO
Imports System.Text

Public Class DumpFileSample
    Private Shared ReadOnly CHUNK_SIZE As Integer = 1024
    Public Shared Sub Main(args() As String)
        Try
            Dim fs As FileStream
            If args.Length > 0 Then
                fs = New FileStream(args(0), FileMode.Open, FileAccess.Read)
            Else
                Throw New ArgumentException()
            End If
            ' use one byte per character encoding for reading dump data
            Dim br As New BinaryReader(fs, New ASCIIEncoding())
            Dim chunk() As Byte

            ' read file chunks until end of file
            Do
                chunk = br.ReadBytes(CHUNK_SIZE)
                ' chunk.Length will be 0 if end of file is reached.
                If chunk.Length > 0
                    DumpBytes(chunk, chunk.Length)
                End If
            Loop While chunk.Length > 0
            fs.Close()
        Catch
            Console.WriteLine("Cannot find or read file to dump.")
        End Try
    End Sub

    Public Shared Sub DumpBytes(bdata() As Byte, len As Integer)
        Dim i As Integer
        Dim j As Integer = 0
        Dim dchar As Char
        ' 3 * 16 chars for hex display, 16 chars for text and 8 chars
        ' for the 'gutter' int the middle.
        Dim dumptext As New StringBuilder("        ", 16 * 4 + 8)
        For i = 0 to len -1
            dumptext.Insert(j * 3, String.Format("{0:X2} ", CType(bdata(i), Integer)))
            dchar = Convert.ToChar(bdata(i))
            ' replace 'non-printable' chars with a '.'.
            If Char.IsWhiteSpace(dchar) Or Char.IsControl(dchar) Then
                dchar = "."
            End If
            dumptext.Append(dchar)
            j += 1
            If j = 16 Then
                Console.WriteLine(dumptext)
                dumptext.Length = 0
                dumptext.Append("        ")
                j = 0
            End If
        Next i
        ' display the remaining line
        If j > 0 Then
            ' add blank hex spots to align the 'gutter'.
            For i = j To 15
                dumptext.Insert(j * 3, "   ")
            Next i
            Console.WriteLine(dumptext)
        End If
    End Sub
End Class

Imports System
Imports System.IO
Imports System.Text

Public Class DumpFileSample
    Private Shared ReadOnly CHUNK_SIZE As Integer = 1024
    Public Shared Sub Main(args() As String)
        Try
            Dim fs As FileStream
            If args.Length > 0 Then
                fs = New FileStream(args(0), FileMode.Open, FileAccess.Read)
            Else
                Throw New ArgumentException()
            End If
            ' use one byte per character encoding for reading dump data
            Dim br As New BinaryReader(fs, New ASCIIEncoding())
            Dim chunk(CHUNK_SIZE) As Byte
            Dim chunksize as Integer

            ' read file chunks until end of file
            Do
                chunksize = br.Read(chunk, 0, CHUNK_SIZE)
                ' chunksize will be 0 if end of file is reached.
                If chunksize > 0
                    DumpBytes(chunk, chunksize)
                End If
            Loop While chunksize > 0
            fs.Close()
        Catch
            Console.WriteLine("Cannot find or read file to dump.")
        End Try
    End Sub

    Public Shared Sub DumpBytes(bdata() As Byte, len As Integer)
        Dim i As Integer
        Dim j As Integer = 0
        Dim dchar As Char
        ' 3 * 16 chars for hex display, 16 chars for text and 8 chars
        ' for the 'gutter' int the middle.
        Dim dumptext As New StringBuilder("        ", 16 * 4 + 8)
        For i = 0 to len -1
            dumptext.Insert(j * 3, String.Format("{0:X2} ", CType(bdata(i), Integer)))
            dchar = Convert.ToChar(bdata(i))
            ' replace 'non-printable' chars with a '.'.
            If Char.IsWhiteSpace(dchar) Or Char.IsControl(dchar) Then
                dchar = "."
            End If
            dumptext.Append(dchar)
            j += 1
            If j = 16 Then
                Console.WriteLine(dumptext)
                dumptext.Length = 0
                dumptext.Append("        ")
                j = 0
            End If
        Next i
        ' display the remaining line
        If j > 0 Then
            ' add blank hex spots to align the 'gutter'.
            For i = j To 15
                dumptext.Insert(j * 3, "   ")
            Next i
            Console.WriteLine(dumptext)
        End If
    End Sub
End Class

using System;
using System.IO;
using System.Text;

public class DumpFileSample
{
    private static readonly int CHUNK_SIZE = 1024;
    public static void Main(String[] args)
    {
        try
        {
            FileStream fs;
            if (args.Length > 0)
            {
                fs = new FileStream(args[0], FileMode.Open, FileAccess.Read);
            }
            else
            {
                throw new ArgumentException();
            }
            // use one byte per character encoding for reading dump data
            BinaryReader br = new BinaryReader(fs, new ASCIIEncoding());
            byte[] chunk;

            // read file chunks until end of file
            do
            {
                // chunk.Length will be 0 if end of file is reached.
                chunk = br.ReadBytes(CHUNK_SIZE);
                if (chunk.Length > 0)
                {
                    DumpBytes(chunk, chunk.Length);
                }
            }
            while (chunk.Length > 0);
            fs.Close();
        }
        catch
        {
            Console.WriteLine("Cannot find or read file to dump.");
        }
    }

    public static void DumpBytes(byte[] bdata, int len)
    {
        int i;
        int j = 0;
        char dchar;
        // 3 * 16 chars for hex display, 16 chars for text and 8 chars
        // for the 'gutter' int the middle.
        StringBuilder dumptext = new StringBuilder("        ", 16 * 4 + 8);
        for (i = 0; i < len; i++)
        {
            dumptext.Insert(j * 3, String.Format("{0:X2} ", (int)bdata[i]));
            dchar = (char)bdata[i];
            //' replace 'non-printable' chars with a '.'.
            if ( Char.IsWhiteSpace(dchar) || Char.IsControl(dchar))
            {
                dchar = '.';
            }
            dumptext.Append(dchar);
            j++;
            if (j == 16)
            {
                Console.WriteLine(dumptext);
                dumptext.Length = 0;
                dumptext.Append("        ");
                j = 0;
            }
        }
        // display the remaining line
        if (j > 0)
        {
            for (i = j; i < 16; i++)
            {
                dumptext.Insert(j * 3, "   ");
            }
            Console.WriteLine(dumptext);
        }
    }
}

using System;
using System.IO;
using System.Text;

public class DumpFileSample
{
    private static readonly int CHUNK_SIZE = 1024;
    public static void Main(String[] args)
    {
        try
        {
            FileStream fs;
            if (args.Length > 0)
            {
                fs = new FileStream(args[0], FileMode.Open, FileAccess.Read);
            }
            else
            {
                throw new ArgumentException();
            }
            // use one byte per character encoding for reading dump data
            BinaryReader br = new BinaryReader(fs, new ASCIIEncoding());
            byte[] chunk = new byte[CHUNK_SIZE];
            int chunksize;

            // read file chunks until end of file
            do
            {
                // chunksize will be 0 if end of file is reached.
                chunksize = br.Read(chunk, 0, CHUNK_SIZE);
                if (chunksize > 0)
                {
                    DumpBytes(chunk, chunksize);
                }
            }
            while (chunksize > 0);
            fs.Close();
        }
        catch
        {
            Console.WriteLine("Cannot find or read file to dump.");
        }
    }

    public static void DumpBytes(byte[] bdata, int len)
    {
        int i;
        int j = 0;
        char dchar;
        // 3 * 16 chars for hex display, 16 chars for text and 8 chars
        // for the 'gutter' int the middle.
        StringBuilder dumptext = new StringBuilder("        ", 16 * 4 + 8);
        for (i = 0; i < len; i++)
        {
            dumptext.Insert(j * 3, String.Format("{0:X2} ", (int)bdata[i]));
            dchar = (char)bdata[i];
            //' replace 'non-printable' chars with a '.'.
            if ( Char.IsWhiteSpace(dchar) || Char.IsControl(dchar))
            {
                dchar = '.';
            }
            dumptext.Append(dchar);
            j++;
            if (j == 16)
            {
                Console.WriteLine(dumptext);
                dumptext.Length = 0;
                dumptext.Append("        ");
                j = 0;
            }
        }
        // display the remaining line
        if (j > 0)
        {
            for (i = j; i < 16; i++)
            {
                dumptext.Insert(j * 3, "   ");
            }
            Console.WriteLine(dumptext);
        }
    }
}

using namespace System;
using namespace System::IO;
using namespace System::Text;

public ref class DumpFileSample
{
private:
    static const int CHUNK_SIZE = 1024;

public:
    static void Main(array<String^>^ args)
    {
        try
        {
            FileStream^ fs;
            if (args->Length > 1)
            {
                fs = gcnew FileStream(args[1], FileMode::Open, FileAccess::Read);
            }
            else
            {
                throw gcnew ArgumentException();
            }
            // use one byte per character encoding for reading dump data
            BinaryReader^ br = gcnew BinaryReader(fs, gcnew ASCIIEncoding());
            array<Byte>^ chunk;

            // read file chunks until end of file
            do
            {
                chunk = br->ReadBytes(CHUNK_SIZE);
                // chunk.Length will be 0 if end of file is reached.
                if (chunk->Length > 0)
                {
                    DumpBytes(chunk, chunk->Length);
                }
            }
            while (chunk->Length > 0);
            fs->Close();
        }
        catch (...)
        {
            Console::WriteLine("Cannot find or read file to dump.");
        }
    }

    static void DumpBytes(array<Byte>^ bdata, int len)
    {
        int i;
        int j = 0;
        Char dchar;
        // 3 * 16 chars for hex display, 16 chars for text and 8 chars
        // for the 'gutter' int the middle.
        StringBuilder^ dumptext = gcnew StringBuilder("        ", 16 * 4 + 8);
        for (i = 0; i < len; i++)
        {
            dumptext->Insert(j * 3, String::Format("{0:X2} ", (int)bdata[i]));
            dchar = (Char)bdata[i];
            // replace 'non-printable' chars with a '.'.
            if ( Char::IsWhiteSpace(dchar) || Char::IsControl(dchar))
            {
                dchar = '.';
            }
            dumptext->Append(dchar);
            j++;
            if (j == 16)
            {
                Console::WriteLine(dumptext);
                dumptext->Length = 0;
                dumptext->Append("        ");
                j = 0;
            }
        }
        // display the remaining line
        if (j > 0)
        {
            for (i = j; i < 16; i++)
            {
                dumptext->Insert(j * 3, "   ");
            }
            Console::WriteLine(dumptext);
        }
    }
};

int main()
{
    DumpFileSample::Main(Environment::GetCommandLineArgs());
}

using namespace System;
using namespace System::IO;
using namespace System::Text;

public ref class DumpFileSample
{
private:
    static const int CHUNK_SIZE = 1024;

public:
    static void Main(array<String^>^ args)
    {
        try
        {
            FileStream^ fs;
            if (args->Length > 1)
            {
                fs = gcnew FileStream(args[1], FileMode::Open, FileAccess::Read);
            }
            else
            {
                throw gcnew ArgumentException();
            }
            // use one byte per character encoding for reading dump data
            BinaryReader^ br = gcnew BinaryReader(fs, gcnew ASCIIEncoding());
            array<Byte>^ chunk = gcnew array<Byte>(CHUNK_SIZE);
            int chunksize;

            // read file chunks until end of file
            do
            {
                chunksize = br->Read(chunk, 0, CHUNK_SIZE);
                // chunksize will be 0 if end of file is reached.
                if (chunksize > 0)
                {
                    DumpBytes(chunk, chunksize);
                }
            }
            while (chunksize > 0);
            fs->Close();
        }
        catch (...)
        {
            Console::WriteLine("Cannot find or read file to dump.");
        }
    }

    static void DumpBytes(array<Byte>^ bdata, int len)
    {
        int i;
        int j = 0;
        Char dchar;
        // 3 * 16 chars for hex display, 16 chars for text and 8 chars
        // for the 'gutter' int the middle.
        StringBuilder^ dumptext = gcnew StringBuilder("        ", 16 * 4 + 8);
        for (i = 0; i < len; i++)
        {
            dumptext->Insert(j * 3, String::Format("{0:X2} ", (int)bdata[i]));
            dchar = (Char)bdata[i];
            // replace 'non-printable' chars with a '.'.
            if ( Char::IsWhiteSpace(dchar) || Char::IsControl(dchar))
            {
                dchar = '.';
            }
            dumptext->Append(dchar);
            j++;
            if (j == 16)
            {
                Console::WriteLine(dumptext);
                dumptext->Length = 0;
                dumptext->Append("        ");
                j = 0;
            }
        }
        // display the remaining line
        if (j > 0)
        {
            for (i = j; i < 16; i++)
            {
                dumptext->Insert(j * 3, "   ");
            }
            Console::WriteLine(dumptext);
        }
    }
};

int main()
{
    DumpFileSample::Main(Environment::GetCommandLineArgs());
}