public override IAsyncResult BeginWrite(byte[] array, int offset, int numBytes, AsyncCallback userCallback, object stateObject);

public override void Write(byte[] array, int offset, int count);

public override void EndWrite(IAsyncResult asyncResult);

using System;

using System.Collections.Generic;

using System.IO;

using System.Linq;

using System.Text;

using System.Threading;

using System.Threading.Tasks;

namespace APMDemo

{

    /// <summary>

    /// 异步向文件写数据，之后验证数据正确性

    /// 写完才能读取，读取完才能验证

    /// </summary>

    class Program

    {

        static void Main(string[] args)

        {

            // 创建一个异步对象，当验证完成后，获得信号

            // ManualResetEvent 通知一个或多个正在等待的线程已发生事件。

            ManualResetEvent manualEvent = new ManualResetEvent(false);

            // 创建随机数据写入文件

            byte[] writeArray = new byte[100000];

            new Random().NextBytes(writeArray);

            FileStream fStream = new FileStream("Test#@@#.dat", FileMode.Create, FileAccess.ReadWrite, FileShare.None, 4096, true);

            // 检查 FileStream 被异步打开

            Console.WriteLine("fStream was {0}opened asynchronously.", fStream.IsAsync ? "" : "not ");

            // 异步写入文件

            IAsyncResult asyncResult = fStream.BeginWrite(writeArray, 0, writeArray.Length,

                                                    new AsyncCallback(EndWriteCallback),

                                                    new State(fStream, writeArray, manualEvent));

            // 并发做些其他事情……等待写入和验证数据

            manualEvent.WaitOne(5000, false);

            Console.ReadKey();

        }

        /// <summary>

        /// 向数据写入文件，当 BeginWrite 完成时，

        /// EndWriteCallback 方法会被调用，结束异步写操作，并且读取和验证数据  

        /// </summary>

        /// <param name="asyncResult"></param>

        static void EndWriteCallback(IAsyncResult asyncResult)

        {

            State tempState = (State)asyncResult.AsyncState;

            FileStream fStream = tempState.FStream;

            fStream.EndWrite(asyncResult);

            // 异步读取已写入的数据

            fStream.Position = 0;

            asyncResult = fStream.BeginRead(tempState.ReadArray, 0, tempState.ReadArray.Length,

                new AsyncCallback(EndReadCallback), tempState);

            // 并发做点其他事情……如日志操作

        }

        /// <summary>

        /// 从文件读取数据，当 BeginRead 完成时，

        /// EndReadCallback 方法被调用，结束异步读取操作，然后验证数据

        /// </summary>

        /// <param name="asyncResult"></param>

        static void EndReadCallback(IAsyncResult asyncResult)

        {

            State tempState = (State)asyncResult.AsyncState;

            int readCount = tempState.FStream.EndRead(asyncResult);

            int i = 0;

            while (i < readCount)

            {

                if (tempState.ReadArray[i] != tempState.WriteArray[i++])

                {

                    Console.WriteLine("Error writing data.");

                    tempState.FStream.Close();

                    return;

                }

            }

            Console.WriteLine("The data was written to {0} and verified.", tempState.FStream.Name);

            tempState.FStream.Close();

            // 当验证完成后，通知主线程

            tempState.ManualEvent.Set();

        }

        /// <summary>

        /// 维护状态信息，传递给 EndWriteCallback 和 EndReadCallback

        /// </summary>

        class State

        {

            // fStream 用于读写文件

            FileStream fStream;

            // writeArray 存储向写入的数据

            byte[] writeArray;

            // readArray 存储从文件读取数据

            byte[] readArray;

            // 当验证完成后，manualEvent 通知主线程

            ManualResetEvent manualEvent;

            public State(FileStream fStream, byte[] writeArray, ManualResetEvent manualEvent)

            {

                this.fStream = fStream;

                this.writeArray = writeArray;

                this.manualEvent = manualEvent;

                readArray = new byte[writeArray.Length];

            }

            public FileStream FStream

            { get { return fStream; } }

            public byte[] WriteArray

            { get { return writeArray; } }

            public byte[] ReadArray

            { get { return readArray; } }

            public ManualResetEvent ManualEvent

            { get { return manualEvent; } }

        }

    }

}

public class AsyncDemo

{

    // The delegate must have the same signature as the method

    // it will call asynchronously.

    public delegate string AsyncMethodCaller(int callDuration, out int threadId);

    // The method to be executed asynchronously.

    public string TestMethod(int callDuration, out int threadId)

    {

        Console.WriteLine("Test method begins.");

        Thread.Sleep(callDuration);

        threadId = Thread.CurrentThread.ManagedThreadId;

        return String.Format("My call time was {0}.", callDuration.ToString());

    }

}

using System;

using System.Threading;

using AsynchronousOperations;

namespace UseEndInvokeToWaitAsyncCall

{

    class Program

    {

        static void Main(string[] args)

        {

            // The asynchronous method puts the thread id here.

            int threadId;

            // Create an instance of the test class.

            AsyncDemo ad = new AsyncDemo();

            // Create the delegate.

            AsyncDemo.AsyncMethodCaller caller = new AsyncDemo.AsyncMethodCaller(ad.TestMethod);

            // Initiate the asychronous call.

            IAsyncResult result = caller.BeginInvoke(3000, out threadId, null, null);

            Thread.Sleep(0);

            Console.WriteLine("Main thread {0} does some work.", Thread.CurrentThread.ManagedThreadId);

            // Call EndInvoke to wait for the asynchronous call to complete,

            // and to retrieve the results.

            string returnValue = caller.EndInvoke(out threadId, result);

            Console.WriteLine("The call executed on thread {0}, with return value \"{1}\".", threadId, returnValue);

            Console.WriteLine("Press any Key to Exit.");

            Console.ReadKey();

        }

    }

}

//This example produces output similar to the following:

//Main thread 10 does some work.

//Test method begins.

//The call executed on thread 6, with return value "My call time was 3000.".

//Press any Key to Exit.

using System;

using System.Threading;

using AsynchronousOperations;

namespace UseWaiHandleToWaitAsyncCall

{

    class Program

    {

        static void Main(string[] args)

        {

            // The asynchronous method puts the thread id here.

            int threadId;

            // Create an instance of the test class.

            AsyncDemo ad = new AsyncDemo();

            // Create the delegate.

            AsyncDemo.AsyncMethodCaller caller = new AsyncDemo.AsyncMethodCaller(ad.TestMethod);

            // Initiate the asychronous call.

            IAsyncResult result = caller.BeginInvoke(3000, out threadId, null, null);

            Thread.Sleep(0);

            Console.WriteLine("Main thread {0} does some work.", Thread.CurrentThread.ManagedThreadId);

            // Wait for the WaitHandle to become signaled.

            result.AsyncWaitHandle.WaitOne();

            // Perform additional processing here.

            // Call EndInvoke to retrieve the results.

            string returnValue = caller.EndInvoke(out threadId, result);

            // Close the wait handle.

            result.AsyncWaitHandle.Close();

            Console.WriteLine("The call executed on thread {0}, with return value \"{1}\".", threadId, returnValue);

            Console.WriteLine("Press any Key to Exit.");

            Console.ReadKey();

        }

    }

}

//This example produces output similar to the following:

//Main thread 8 does some work.

//Test method begins.

//The call executed on thread 9, with return value "My call time was 3000.".

//Press any Key to Exit.

using System;

using System.Threading;

using AsynchronousOperations;

namespace PollUntilAsyncComplete

{

    class Program

    {

        static void Main(string[] args)

        {

            // The asynchronous method puts the thread id here.

            int threadId;

            // Create an instance of the test class.

            AsyncDemo ad = new AsyncDemo();

            // Create the delegate.

            AsyncDemo.AsyncMethodCaller caller = new AsyncDemo.AsyncMethodCaller(ad.TestMethod);

            // Initiate the asychronous call.

            IAsyncResult result = caller.BeginInvoke(3000, out threadId, null, null);

            // Poll while simulating work.

            while (result.IsCompleted == false)

            {

                Thread.Sleep(250);

                Console.Write(".");

            }

            // Call EndInvoke to retrieve the results.

            string returnValue = caller.EndInvoke(out threadId, result);

            Console.WriteLine("\nThe call executed on thread {0}, with return value \"{1}\".", threadId, returnValue);

            Console.WriteLine("Press any Key to Exit.");

            Console.ReadKey();

        }

    }

}

//This example produces output similar to the following:

//Test method begins.

//............

//The call executed on thread 10, with return value "My call time was 3000.".

//Press any Key to Exit.

using System;

using System.Runtime.Remoting.Messaging;

using System.Threading;

using AsynchronousOperations;

namespace WhenAsyncIsCompletedRunAsyncCallback

{

    class Program

    {

        static void Main(string[] args)

        {

            // Create an instance of the test class.

            AsyncDemo ad = new AsyncDemo();

            // Create the delegate.

            AsyncDemo.AsyncMethodCaller caller = new AsyncDemo.AsyncMethodCaller(ad.TestMethod);

            // The threadId parameter of TestMethod is an out parameter, so

            // its input value is never used by TestMethod. Therefore, a dummy

            // variable can be passed to the BeginInvoke call. If the threadId

            // parameter were a ref parameter, it would have to be a class-

            // level field so that it could be passed to both BeginInvoke and 

            // EndInvoke.

            int dummy = 0;

            // Initiate the asynchronous call, passing three seconds (3000 ms)

            // for the callDuration parameter of TestMethod; a dummy variable 

            // for the out parameter (threadId); the callback delegate; and

            // state information that can be retrieved by the callback method.

            // In this case, the state information is a string that can be used

            // to format a console message.

            IAsyncResult result = caller.BeginInvoke(3000,

                out dummy,

                new AsyncCallback(CallbackMethod),

                "The call executed on thread {0}, with return value \"{1}\".");

            Console.WriteLine("The main thread {0} continues to execute...", Thread.CurrentThread.ManagedThreadId);

            // The callback is made on a ThreadPool thread. ThreadPool threads

            // are background threads, which do not keep the application running

            // if the main thread ends. Comment out the next line to demonstrate

            // this.

            Thread.Sleep(4000);

            Console.WriteLine("The main thread ends.");

            Console.WriteLine("Press any Key to Exit.");

            Console.ReadKey();

        }

        // The callback method must have the same signature as the

        // AsyncCallback delegate.

        static void CallbackMethod(IAsyncResult ar)

        {

            // Retrieve the delegate.

            AsyncResult result = (AsyncResult)ar;

            AsyncDemo.AsyncMethodCaller caller = (AsyncDemo.AsyncMethodCaller)result.AsyncDelegate;

            // Retrieve the format string that was passed as state 

            // information.

            string formatString = (string)ar.AsyncState;

            // Define a variable to receive the value of the out parameter.

            // If the parameter were ref rather than out then it would have to

            // be a class-level field so it could also be passed to BeginInvoke.

            int threadId = 0;

            // Call EndInvoke to retrieve the results.

            string returnValue = caller.EndInvoke(out threadId, ar);

            // Use the format string to format the output message.

            Console.WriteLine(formatString, threadId, returnValue);

        }

    }

}

//This example produces output similar to the following:

//Test method begins.

//The main thread 9 continues to execute...

//The call executed on thread 6, with return value "My call time was 3000.".

//The main thread ends.

//Press any Key to Exit.