.NET “底层”异步编程模式——异步编程模型（Asynchronous Programming Model，APM）

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);

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.