Listing 1: An implementation of IAsynchResult

• By Eric Vogel
• 03/24/2011

public interface IAsyncResult
{
object AsyncState { get; }
WaitHandle AsyncWaitHandle { get; }
bool CompletedSynchronously { get; }
bool IsCompleted { get; }
}
¬  public class AsynchResult<TArg, TResult> : IAsyncResult
    {
        private readonly AsyncCallback m_asynchCallBack;
        private readonly Object m_asychState;
        private int m_completedState;
        private ManualResetEvent m_asynchWaitHandle;
        private Exception m_exception;
        private TResult m_result = default(TResult);
        private TArg m_arg = default(TArg);

        public TArg Arg { get { return m_arg; } }

        public AsynchResult(TArg arg, AsyncCallback callback, Object state)
        {
            m_arg = arg;
            m_asynchCallBack = callback;
            m_asychState = state;
        }

        public void SetAsCompleted(TResult result, bool completedSynchronously, Exception exception)
        {
            m_result = result;
            m_exception = exception;

            int previous = Interlocked.Exchange(ref m_completedState, 
                completedSynchronously ? (int) AsynchronousState.CompletedSychronously : (int) AsynchronousState.
                     CompletedAsynchronously);
            
            if (previous != (int)AsynchronousState.Pending)
            {
                throw new InvalidOperationException("A result has already been set");
            }

            if (m_asynchWaitHandle != null)
            {
                m_asynchWaitHandle.Set();
            }

            if (m_asynchCallBack != null)
            {
                m_asynchCallBack(this);
            }
        }

        public TResult EndInvoke()
        {
            if (!IsCompleted)
            {
                AsyncWaitHandle.WaitOne();
                AsyncWaitHandle.Close();
                m_asynchWaitHandle = null;
            }

            if (m_exception != null)
            {
                throw m_exception;
            }

            return m_result;
        }

        #region IAsyncResult Members

        public object AsyncState
        {
            get 
            {
                return m_asychState; 
            }
        }

        public System.Threading.WaitHandle AsyncWaitHandle
        {
            get 
            {
                if (m_asynchWaitHandle == null)
                {
                    bool done = IsCompleted;
                    ManualResetEvent resetEvent = new ManualResetEvent(done);

                    if (Interlocked.CompareExchange(ref m_asynchWaitHandle, resetEvent, null)
                        != null)
                    {
                        resetEvent.Close();
                    }
                    else
                    {
                        if (!done && IsCompleted)
                        {
                            m_asynchWaitHandle.Set();
                        }
                    }
                }

                return m_asynchWaitHandle;
            }
        }

        public bool CompletedSynchronously
        {
            get 
            {
                return Thread.VolatileRead(ref m_completedState) == (int)AsynchronousState.CompletedSychronously;
            }
        }

        public bool IsCompleted
        {
            get { return Thread.VolatileRead(ref m_completedState) != (int)AsynchronousState.Pending; }
        }

        #endregion
    }