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.**cn*blogs.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);
}
);
}