Windows Phone 7 异步编程模型详解

public delegate void AsyncCallback(IAsyncResult ar);

(4)IAsyncResult接口
它表示异步操作的状态.
该接口定义了4个公用属性
public interface IAsyncResult
 { 
object AsyncState { get; }
 WaitHandle AsyncWaitHandle { get; }
  bool CompletedSynchronously { get; }
 bool IsCompleted { get; }
 }

using System;
using System.Threading;

namespace AsyncTaskDemo
{
    public class AsyncResultNoResult : IAsyncResult
    {
        private readonly AsyncCallback _asyncCallback;//异步请求的返回方法
        private readonly object _asyncState;//异步请求的对象

        private ManualResetEvent _asyncWaitHandle;//线程阻塞

        private Exception _exception;//操作异常

        private int _completedState;//完成状态
        private const int StateCompletedAsynchronously = 2;//异步完成
        private const int StateCompletedSynchronously = 1;//同步完成
        private const int StatePending = 0;
        ///

        private static void RethrowException(Exception ex)
        {
            throw ex;
        }

        public void SetAsCompleted(Exception exception, bool completedSynchronously)
        {
            // Passing null for exception means no error occurred.
            // This is the common case
            this._exception = exception;
            // The m_CompletedState field MUST be set prior calling the callback
            if (Interlocked.Exchange(ref this._completedState, completedSynchronously ? 1 : 2) != 0)
            {
               
                throw new InvalidOperationException("You can set a result only once", exception);
            }
            if (this._asyncWaitHandle != null)
            {// If the event exists, set it
                this._asyncWaitHandle.Set();
            }
            if (this._asyncCallback != null)
            {// If a callback method was set, call it
                this._asyncCallback(this);//调用异步请求的返回方法
            }
        }
        ///

        public WaitHandle AsyncWaitHandle
        {
            get
            {
               
                if (this._asyncWaitHandle == null)
                {
                    bool isCompleted = this.IsCompleted;
                    ManualResetEvent event2 = new ManualResetEvent(isCompleted);
                    if (Interlocked.CompareExchange(ref this._asyncWaitHandle, event2, null) != null)
                    {
                        // Another thread created this object's event; dispose
                        // the event we just created
                        event2.Close();
                    }
                    else if (!isCompleted && this.IsCompleted)
                    {
                        // If the operation wasn't done when we created
                        // the event but now it is done, set the event
                        //如果操作已经完成则释放阻塞
                        this._asyncWaitHandle.Set();
                    }
                }
                return this._asyncWaitHandle;
            }
        }
        //同步操作是否已经完成
        public bool CompletedSynchronously
        {
            get
            {
                return (this._completedState == 1);
            }
        }
        //是否已经完成
        public bool IsCompleted
        {
            get
            {
                return (this._completedState != 0);
            }
        }
    }
}

using System;

namespace AsyncTaskDemo
{
    public class AsyncResult : AsyncResultNoResult
    {
        private TResult m_result;//异步操作完成返回的对象

        public AsyncResult(AsyncCallback asyncCallback, object state)
            : base(asyncCallback, state)
        {
            this.m_result = default(TResult);
        }
        ///

using System;
using System.Threading;

namespace AsyncTaskDemo
{
    public class TestTask
    {
        public TestTask()
        {
        }

        public IAsyncResult BeginTestTask(string text, AsyncCallback asyncCallback, object state)
        {
            AsyncResult asyncResult = new AsyncResult(asyncCallback, state);
            ThreadPool.QueueUserWorkItem(DoTestTask, asyncResult);
            return asyncResult;
        }

        public string EndTestTask(IAsyncResult asyncResult)
        {
            return ((AsyncResult)asyncResult).EndInvoke();
        }

        private void DoTestTask(Object asyncResult)
        {
            AsyncResult ar = (AsyncResult)asyncResult;
            try
            {
                Thread.Sleep(3000);
                ar.SetAsCompleted("测试完成", true);
            }
            catch (Exception e)
            {
                ar.SetAsCompleted(e, false);
            }
        }
    }
}

TestTask tt = new TestTask();
        WebTask webTask = new WebTask(new Uri("http://www.cnblogs.com/linzheng"));
        IAsyncResult ia;
        public MainPage()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, RoutedEventArgs e)
        {
           
            Func> testResult = Observable.FromAsyncPattern(tt.BeginTestTask, tt.EndTestTask);

            ObservableExtensions.Subscribe(
               Observable.ObserveOnDispatcher
               (
               testResult.Invoke("")
             ),
              delegate(string success)
              {
                  MessageBox.Show(success);
              },
              delegate(Exception exception)
              {
                  MessageBox.Show(exception.Message);
              }
              );
        }