SimpleAsyncResult

using System;
using System.Threading;

namespace APMResearch
{
    public delegate T Func<T>();

    public class SimpleAsyncResult<T> :IAsyncResult
    {
        private volatile int _mIsCompleted;
        private readonly ManualResetEvent _asyncWaitHandle;
        private readonly AsyncCallback _callback;
        private readonly object _asyncState;

        private Exception _exception;
        private T _result;

        private SimpleAsyncResult(Func<T> work,AsyncCallback callback,object state )
        {
            _callback = callback;
            _asyncState = state;
            _asyncWaitHandle=new ManualResetEvent(false);

            RunWorkAsynchronously(work);
        }

        public bool IsCompleted
        {
            get { return _mIsCompleted == 1; }
        }

        public WaitHandle AsyncWaitHandle
        {
            get { return _asyncWaitHandle; }
        }

        public object AsyncState
        {
            get { return _asyncState; }
        }

        public bool CompletedSynchronously
        {
            get { return false; }
        }

        private void RunWorkAsynchronously(Func<T> work)
        {
            ThreadPool.QueueUserWorkItem(delegate
                                             {
                                                 try
                                                 {
                                                     _result = work();
                                                 }
                                                 catch (Exception e)
                                                 {

                                                     _exception = e;
                                                 }
                                                 finally
                                                 {
                                                     _mIsCompleted = 1;
                                                     _asyncWaitHandle.Set();
                                                     if (_callback != null)
                                                         _callback(this);
                                                 }
                                             });
        }

        public T End()
        {
            if(_mIsCompleted!=1)
            {
                _asyncWaitHandle.WaitOne();
                _asyncWaitHandle.Close();
            }

            if (_exception != null)
                throw _exception;

            return _result;
        }
    }
}