Csharp/C Sharp/File Stream/Asynchronous Input output

Asynchronous Writing, Asynchronous Reading

//Code revised from Chapter 25 - Accessing Data Streams
//C# Bible
//by Jeff Ferguson et al. 

using System;
using System.IO;
using System.Threading;
   
class FileTestClass
{
    private static FileStream    BinaryFile = new FileStream("test.dat", FileMode.Create, FileAccess.ReadWrite);
    private static byte []       ByteArray = new byte [256];
    private static IAsyncResult  AsyncReadResultImplementation = null;
    private static IAsyncResult  AsyncWriteResultImplementation;
    private static AsyncCallback ReadBytesCompleteCallback = new AsyncCallback(OnReadBytesComplete);
    private static AsyncCallback WriteBytesCompleteCallback = new AsyncCallback(OnWriteBytesComplete);
    
   
    public static void OnReadBytesComplete(IAsyncResult AsyncResult)
    {
        int BytesRead;
        int Failures;
   
        BytesRead = BinaryFile.EndRead(AsyncResult);
        Console.WriteLine("Bytes read........: {0}", BytesRead);
        Failures = 0;
        for(int i = 0; i < 256; i++)
        {
            if(ByteArray[i] != (byte)i)
            {
                Console.WriteLine("Read test failed for byte at offset {0}.", i);
                Failures++;
            }
        }
        Console.WriteLine("Read test failures: {0}", Failures);
    }
    public static void OnWriteBytesComplete(IAsyncResult AsyncResult)
    {
        BinaryFile.EndWrite(AsyncResult);
    }
    static public void Main()
    {
        for(int i = 0; i < 256; i++)
            ByteArray[i] = (byte)i;
        AsyncWriteResultImplementation = BinaryFile.BeginWrite(ByteArray, 0, 256, WriteBytesCompleteCallback, null);

        WaitHandle WaitOnWriteIO = AsyncWriteResultImplementation.AsyncWaitHandle;
        WaitOnWriteIO.WaitOne();

        BinaryFile.Seek(0, SeekOrigin.Begin);
        AsyncReadResultImplementation = BinaryFile.BeginRead(ByteArray, 0, 256, ReadBytesCompleteCallback, null);
        WaitHandle WaitOnReadIO = AsyncReadResultImplementation.AsyncWaitHandle;
        WaitOnReadIO.WaitOne();
    }
}

illustrates asynchronous I/O

/*
Mastering Visual C# .NET
by Jason Price, Mike Gunderloy
Publisher: Sybex;
ISBN: 0782129110
*/
 /*
  Example15_18.cs illustrates asynchronous I/O
*/
using System;
using System.IO;
using System.Windows.Forms;
public class Example15_18 
{
  // stream to handle reading
  private static FileStream inStream;
  // delegated method to handle callback
  private static AsyncCallback acb;
  // allocate a big buffer for reading
  static byte[] buf = new byte[500000];
  // callback to use when read is complete
  static void OnComplete(IAsyncResult asyncResult)
  {
    int bytesRead = inStream.EndRead(asyncResult);
    Console.Write(bytesRead);
    Console.WriteLine(" bytes read!");
  }
    
    [STAThread]
  public static void Main() 
  {
    // use an open file dialog to get a filename
    OpenFileDialog dlgOpen = new OpenFileDialog();
    dlgOpen.Title="Select file to read";
    if (dlgOpen.ShowDialog() == DialogResult.OK)
    {
      // open the file
      inStream = new FileStream(dlgOpen.FileName, FileMode.Open, 
       FileAccess.Read, FileShare.None, 2048, true);
      // assign the callback delegate
      acb = new AsyncCallback(OnComplete);
      // read asynchronously
      inStream.BeginRead(buf, 0, 500000, acb, null);
      // do some work in the meantime
      for(int i=0; i<10; i++)
        Console.WriteLine(i);
      // And wait for the user to quit
      Console.WriteLine("Press Enter to exit");
      int resp = Console.Read();
    }
  }
}

Synchronous Writing, Asynchronous Reading

//Code revised from Chapter 25 - Accessing Data Streams
//C# Bible
//by Jeff Ferguson et al. 
using System;
using System.IO;
using System.Threading;
   
class FileTestClass
{
    private static FileStream    BinaryFile = new FileStream("test.dat", FileMode.Create, FileAccess.ReadWrite);
    private static byte []       ByteArray = new byte [256];
    private static IAsyncResult  AsyncResultImplementation;
    private static AsyncCallback ReadBytesCompleteCallback= new AsyncCallback(OnReadBytesComplete);
    public static void OnReadBytesComplete(IAsyncResult AsyncResult)
    {
        int BytesRead;
        int Failures;
   
        BytesRead = BinaryFile.EndRead(AsyncResult);
        Failures = 0;
        for(int i = 0; i < 256; i++)
        {
            if(ByteArray[i] != (byte)i)
            {
                Console.WriteLine("Read test failed for byte at offset {0}.", i);
                Failures++;
            }
        }
    }
    static public void Main()
    {
        for(int i = 0; i < 256; i++)
            ByteArray[i] = (byte)i;
        BinaryFile.Write(ByteArray, 0, 256);
        BinaryFile.Seek(0, SeekOrigin.Begin);
        AsyncResultImplementation = BinaryFile.BeginRead(ByteArray, 0, 256, ReadBytesCompleteCallback, null);
        WaitHandle WaitOnReadIO = AsyncResultImplementation.AsyncWaitHandle;
        WaitOnReadIO.WaitOne();
    }    
}