public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
 {
     read = new AsyncResult() { AsyncState = state };
     read.bytesRead = Read(buffer, offset, count);
     callback(read);
     return read;
 }

        public IAsyncResult BeginGetQuestionnaireTemplateSummary(QuestionnaireTemplate questionnaireTemplate, AsyncCallback callback, object asyncState)
        {
            var result = new AsyncResult<QuestionnaireTemplateSummary>(callback, asyncState);
            HandleBeginGetQuestionnaireTemplateSummary(result);

            return result;
        }

      public IAsyncResult BeginWrite(ReaderWriterGateCallback callback, Object state,
        AsyncCallback asyncCallback, Object asyncState) {
         AsyncResult<Object> ar = new AsyncResult<Object>(asyncCallback, asyncState);
         ReaderWriterGateReleaser releaser = new ReaderWriterGateReleaser(callback, this, false, state, ar);
         m_syncLock.Enter(true);
         switch (m_state) {
            case ReaderWriterGateStates.Free:             // If Free "RFW -> OBW, invoke, return
            case ReaderWriterGateStates.ReservedForWriter:
               m_state = ReaderWriterGateStates.OwnedByWriter;
               ThreadPool.QueueUserWorkItem(releaser.Invoke);
               break;

            case ReaderWriterGateStates.OwnedByReaders:   // If OBR | OBRAWP -> OBRAWP, queue, return
            case ReaderWriterGateStates.OwnedByReadersAndWriterPending:
               m_state = ReaderWriterGateStates.OwnedByReadersAndWriterPending;
               m_qWriteRequests.Enqueue(releaser);
               break;

            case ReaderWriterGateStates.OwnedByWriter:   // If OBW, queue, return
               m_qWriteRequests.Enqueue(releaser);
               break;
         }
         m_syncLock.Leave();
         return ar;
      }

        public IAsyncResult BeginGetQuestionnaire(AsyncCallback callback, object asyncState)
        {
            var result = new AsyncResult<Questionnaire>(callback, asyncState);
            HandleBeginGetQuestionnaire(result);

            return result;
        }

 public IAsyncResult BeginConnect(string hostName, int port, AsyncCallback callback = null, object state = null)
 {
     var ar = new AsyncResult(state) { Hostname = hostName, Port = port };
     ar.Client = new TcpClient();
     ar.Client.BeginConnect(_info.ProxyHostname, _info.ProxyPort, OnConnected, ar);
     return ar;
 }

        public override IAsyncResult BeginDownloadXml(Uri feeduri, AsyncCallback callback)
        {
#if !WINDOWS_PHONE
            if (!IsolatedStorageFile.IsEnabled) throw new MissingFeedException("IsolatedStorage is not enabled! Cannot access files from IsolatedStorage!");
#endif


            try
            {
                using (var store = IsolatedStorageFile.GetUserStoreForApplication())
                {
                    if(!PingFeed(feeduri, store)) throw new MissingFeedException(string.Format("Could not find feed at location {0}", feeduri));

                    using (var stream = new IsolatedStorageFileStream(feeduri.OriginalString, FileMode.Open,
                                                                   FileAccess.Read, store))
                    {
                        using(var reader = new StreamReader(stream))
                        {
                            var strOutput = reader.ReadToEnd();
                            //Fake the async result
                            var result = new AsyncResult<FeedTuple>(callback, new FeedTuple { FeedContent = strOutput, FeedUri = feeduri }, true);
                            if (callback != null) callback.Invoke(result);
                            return result;
                        }
                    }
                }
            }
            catch (IsolatedStorageException ex)
            {
                throw new MissingFeedException(string.Format("Unable to open feed at {0}", feeduri), ex);
            }
        }

        public IAsyncResult BeginGetQuestionnaireTemplates(AsyncCallback callback, object asyncState)
        {
            var result = new AsyncResult<IEnumerable<QuestionnaireTemplate>>(callback, asyncState);
            HandleBeginGetQuestionnaireTemplates(result);

            return result;
        }

        public void WhenCreated_ThenIsNotComplete()
        {
            var result = new AsyncResult<object>(null, this);

            Assert.IsFalse(result.IsCompleted);
            Assert.IsFalse(result.CompletedSynchronously);
        }

 public when_asyncressult_completes_on_different_thread()
 {
     asyncResult = new AsyncResult<int>(ar => Thread.VolatileWrite(ref callbackWasInvoked, 1), null);
     ThreadPool.QueueUserWorkItem(_ => asyncResult.Complete(true, ExpectedResult));
     // give the thread-pool thread time to invoke the callback
     Thread.Sleep(100);
 }

        public IAsyncResult BeginSubmitResponses(Questionnaire questionnaire, AsyncCallback callback, object asyncState)
        {
            var result = new AsyncResult<object>(callback, asyncState);
            HandleBeginSubmitResponses(result);

            return result;
        }

    public void SetResult(AsyncResult asyncResult, object result)
    {
        lock (this._Lock)
        {
            List<TemporalAsyncResult> willRemovedTemporalAsyncResults = new List<TemporalAsyncResult>();
            DateTime now = DateTime.UtcNow;
            foreach(TemporalAsyncResult item in this._TemporalAsyncResults.Values)
            {
                if (now - item.TimeStamp > this._LiveTime)
                {
                    willRemovedTemporalAsyncResults.Add(item);
                }
            }
            foreach (TemporalAsyncResult item in willRemovedTemporalAsyncResults)
            {
                //AppDebug.LogEvent("AsyncResultManager.SetResult", string.Format("Delete timeout async result {0}, {1}", item.AsyncResult.Id, item.AsyncResult.MethodName), System.Diagnostics.EventLogEntryType.Information);

                this._Results.Remove(item.AsyncResult.Id);
                this._TemporalAsyncResults.Remove(item.AsyncResult.Id);
            }

            //AppDebug.LogEvent("AsyncResultManager.SetResult", string.Format("Set result of {0}, {1}", asyncResult.Id, asyncResult.MethodName), System.Diagnostics.EventLogEntryType.Information);
            this._Results.Add(asyncResult.Id, result);
            this._TemporalAsyncResults.Add(asyncResult.Id, new TemporalAsyncResult(asyncResult));
        }
    }

 private static void Finally(AsyncResult result, Exception currentException)
 {
     SqlWorkflowInstanceStoreAsyncResult result2 = result as SqlWorkflowInstanceStoreAsyncResult;
     try
     {
         if (result2.DependentTransaction != null)
         {
             using (result2.DependentTransaction)
             {
                 result2.DependentTransaction.Complete();
             }
         }
     }
     catch (TransactionException)
     {
         if (currentException == null)
         {
             throw;
         }
     }
     finally
     {
         result2.OnCommandCompletion();
         result2.ClearMembers();
         StoreUtilities.TraceSqlCommand(result2.sqlCommand, false);
     }
 }

        public void WhenCompleted_ThenESetsResult()
        {
            var result = new AsyncResult<object>(null, null);

            result.SetComplete(this, true);

            Assert.AreSame(this, result.Result);
        }

        public IAsyncResult BeginReceiveMessage(AsyncCallback asyncCallback, object state)
        {
            var asyncResult = new AsyncResult<string>(asyncCallback, state);

            ReturnMessageOrBeginReceive(asyncResult, true);

            return asyncResult;
        }

 public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
 {
     //Console.WriteLine("SMS writing " + count + " bytes.");
     write = new AsyncResult() { AsyncState = state };
     Write(buffer, offset, count);
     callback(write);
     return write;
 }

 public IAsyncResult BeginAsyncAction(Action action)
 {
     var asyncresult = new AsyncResult()
                          {
                              Action =  action
                          };
     _queue.Enqueue(asyncresult);
     return asyncresult;
 }

		public TransferItem(byte[] buffer, int offset, int size, AsyncResult asyncResult, DataType type) {
			this.Buffer = buffer;
			this.Offset = offset;
			this.Size = size;
			this.AsyncResult = asyncResult;
			this.Transferred = 0;
			this.Type = type;
			this.OriginalSize = size;
		}

 // Asynchronous version of time-consuming method (Begin part)
 public IAsyncResult BeginDoTask(AsyncCallback callback, Object state)
 {
     // Create IAsyncResult object identifying the
     // asynchronous operation
     AsyncResult<DateTime> ar = new AsyncResult<DateTime>(callback, state);
     // Use a thread pool thread to perform the operation
     ThreadPool.QueueUserWorkItem(DoTaskHelper, ar);
     return ar; // Return the IAsyncResult to the caller
 }

        public AccountSummaryArgument(string tradeDay, string accountIds, string rdlc, AsyncResult asyncResult, long session)
            : base(session)
        {
            this._TradeDay = tradeDay;
            this._AccountIds = accountIds;
            this._Rdlc = rdlc;

            this._AsyncResult = asyncResult;
        }

        public void WhenCompleted_ThenExecutesCallback()
        {
            bool executed = false;
            var result = new AsyncResult<object>(ar => executed = true, null);

            result.SetComplete(null, true);

            Assert.IsTrue(executed);
        }