异步编程模型使用 IAsyncResult 对象

先推荐阅读下面的资料：

MSDN：异步编程设计模式

IBM developerworks： 使用异步 I/O 大大提高应用程序的性能

参考博文：

1、正确使用异步操作 

2、Lab：体会ASP.NET异步处理请求的效果

3、WCF中的异步调用

4、WCF从理论到实践(11)-异步

5、异步编程

.NET Framework 为异步操作提供两种设计模式：
1、使用 IAsyncResult 对象的异步操作。
2、使用事件的异步操作。

IAsyncResult接口类型

    [ComVisible(true)]
    public interface IAsyncResult
    {
        // 摘要:
        //     获取用户定义的对象，它限定或包含关于异步操作的信息。
        //
        // 返回结果:
        //     用户定义的对象，它限定或包含关于异步操作的信息。
        object AsyncState { get; }
        //
        // 摘要:
        //     获取用于等待异步操作完成的 System.Threading.WaitHandle。
        //
        // 返回结果:
        //     用于等待异步操作完成的 System.Threading.WaitHandle。
        WaitHandle AsyncWaitHandle { get; }
        //
        // 摘要:
        //     获取异步操作是否同步完成的指示。
        //
        // 返回结果:
        //     如果异步操作同步完成，则为 true；否则为 false。
        bool CompletedSynchronously { get; }
        //
        // 摘要:
        //     获取异步操作是否已完成的指示。
        //
        // 返回结果:
        //     如果操作完成则为 true，否则为 false。
        bool IsCompleted { get; }
    }

下面是使用 IAsyncResult 对象的测试代码。

 public delegate string AsyncDelegate(int callDuration, out int threadId);
    class Program
    {
        static void Main(string[] args)
        {
            Fun1();
            Console.ReadLine();
        }

        private static int threadId;

        //阻塞等待   使用 EndInvoke 等待异步调用  
        static void Fun1()
        {
            //创建示例类的实例。
            AsyncDemo ad = new AsyncDemo();
            // 创建委托
            AsyncDelegate dlgt = new AsyncDelegate(ad.TestMethod);
            // 委托在这里开始异步调用。
            IAsyncResult ar = dlgt.BeginInvoke(5000,out threadId, null, null);
            //人为的线程阻塞。
            Thread.Sleep(0);
            Console.WriteLine("主线程 {0}开始工作",Thread.CurrentThread.ManagedThreadId);
            // 委托开始EndInvoke调用，这个过程会使主线程等待异步调用完成并返回结果。
            string ret = dlgt.EndInvoke(out threadId, ar);
            Console.WriteLine("异步线程 {0},返回值 \"{1}\".", threadId, ret);
            Console.WriteLine("主线程{0}结束工作", Thread.CurrentThread.ManagedThreadId);
        }
        
        //阻塞等待  使用 WaitHandle 等待异步调用
        static void Fun2()
        {
            AsyncDemo ad = new AsyncDemo();
            AsyncDelegate dlgt = new AsyncDelegate(ad.TestMethod);
            IAsyncResult ar = dlgt.BeginInvoke(5000,out threadId, null, null);
            Thread.Sleep(0);
            Console.WriteLine("主线程 {0}开始工作", Thread.CurrentThread.ManagedThreadId);
            //主线程在这里等待，直到异步线程执行完。
            ar.AsyncWaitHandle.WaitOne();
            // 和前一方案的区别在于，你可以在异步调用完成后，获取异步调用返回值之前
            //在这里做点任何你想作的事。
            //调用EndInvoke获取异步调用的返回结果.
            string ret = dlgt.EndInvoke(out threadId, ar);
            Console.WriteLine("异步线程 {0},返回值 \"{1}\".", threadId, ret);
            Console.WriteLine("主线程{0}结束工作", Thread.CurrentThread.ManagedThreadId);
        }

        //轮询状态    轮询异步调用完成
        static void Fun3()
        {
            AsyncDemo ad = new AsyncDemo();
            AsyncDelegate dlgt = new AsyncDelegate(ad.TestMethod);
            IAsyncResult ar = dlgt.BeginInvoke(5000,out threadId, null, null);
            Console.WriteLine("主线程 {0}开始工作", Thread.CurrentThread.ManagedThreadId);
            //这里每隔10毫秒就检测（轮询）一下异步执行的状态，
            //直到异步调用完成，IsCompleted的值变为ture为止。
            while (ar.IsCompleted == false)
            {
                Thread.Sleep(10);
            }

            //还记得微软的那个善意的提醒吗？虽然IsCompleted为true了，
            //我们还是调用一下EndInvoke，来获取返回值。
            string ret = dlgt.EndInvoke(out threadId, ar);
            Console.WriteLine("异步线程 {0},返回值 \"{1}\".", threadId, ret);
            Console.WriteLine("主线程{0}结束工作", Thread.CurrentThread.ManagedThreadId);
        }

        //通知机制    异步调用完成时执行回调方法
        static void Fun4()
        {
            AsyncDemo ad = new AsyncDemo();
            AsyncDelegate dlgt = new AsyncDelegate(ad.TestMethod);
            //注意第三个参数，这就是我们要用到的回调方法。
            //第四个参数更为有趣，它可以是任何Object对象，这里它就是
            //执行异步调用的委托本身，把委托本身传递进去的原因在下面可以看到。
            Console.WriteLine("主线程 {0}开始工作", Thread.CurrentThread.ManagedThreadId);
            IAsyncResult ar = dlgt.BeginInvoke(5000,out threadId, new AsyncCallback(CallbackMethod), dlgt);
            Console.WriteLine("主线程 {0}结束工作", Thread.CurrentThread.ManagedThreadId);
            Console.ReadLine();
        }
        //回调函数必须严格的遵照AsyncCallback委托的签名。
        static void CallbackMethod(IAsyncResult ar)
        {
            //在这里，上面那个dlgt作为参数的作用得到了体现，原来它就是为了完成对EndInvoke的调用啊。
            AsyncDelegate dlgt = (AsyncDelegate)ar.AsyncState;
            //通过对EndInvoke的调用获取返回值。
            string ret = dlgt.EndInvoke(out threadId, ar);
            Console.WriteLine("异步线程 {0},返回值 \"{1}\".", threadId, ret);
        }
    }
    //使用异步编程模型 
    public class AsyncDemo
    {
        public string TestMethod(int callDuration, out int threadId)
        {
            Console.WriteLine("异步方法开始工作");
            Thread.Sleep(callDuration);
            threadId = Thread.CurrentThread.ManagedThreadId; 
            return "异步方法执行时间 " + callDuration.ToString();
        }
    }

 执行结果：

Fun1--------------------

异步方法开始工作
主线程 10开始工作
异步线程 7,返回值 "异步方法执行时间 5000".
主线程10结束工作
Fun2---------------------
异步方法开始工作
主线程 10开始工作
异步线程 7,返回值 "异步方法执行时间 5000".
主线程10结束工作
Fun3---------------------

主线程 10开始工作
异步方法开始工作
异步线程 7,返回值 "异步方法执行时间 5000".
主线程10结束工作
Fun4---------------------
主线程 10开始工作
主线程 10结束工作
异步方法开始工作
异步线程 7,返回值 "异步方法执行时间 5000".
--------------------------

工作当中有一个调用ActiveMQ的产品，每天大概是上万的消息。压力也不是很大。最近总是出现调用MQ阻塞的情况。负责MQ的同事也没有找到原因。

我是想寻找一个消息队列的代替品。 上面的第四个方法，异步线程不阻塞调用线程，当然调用线程也无需处理调用结果，貌似可以作为一个代替方案。