Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Web/HttpAsyncResult.cs

@@ -0,0 +1,142 @@
+//------------------------------------------------------------------------------
+// <copyright file="HttpAsyncResult.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>                                                                
+//------------------------------------------------------------------------------
+
+/*
+ * ASP.NET simple internal implementation of IAsyncResult
+ * 
+ * Copyright (c) 2000 Microsoft Corporation
+ */
+
+namespace System.Web {
+    using System;
+    using System.Threading;
+    using System.Web.Util;
+
+    internal class HttpAsyncResult : IAsyncResult {
+        private AsyncCallback _callback;
+        private Object        _asyncState;
+
+        private bool          _completed;
+        private bool          _completedSynchronously;
+
+        private Object        _result;
+        private Exception     _error;
+        private Thread        _threadWhichStartedOperation;
+
+        // pipeline support
+        private RequestNotificationStatus
+                              _status;
+
+        /*
+         * Constructor with pending result
+         */
+        internal HttpAsyncResult(AsyncCallback cb, Object state) {
+            _callback    = cb;
+            _asyncState  = state;
+            _status      = RequestNotificationStatus.Continue;
+        }
+
+        /*
+         * Constructor with known result
+         */
+        internal HttpAsyncResult(AsyncCallback cb, Object state,
+                                 bool completed, Object result, Exception error) {
+            _callback    = cb;
+            _asyncState  = state;
+
+            _completed = completed;
+            _completedSynchronously = completed;
+
+            _result = result;
+            _error = error;
+            _status = RequestNotificationStatus.Continue;
+
+            if (_completed && _callback != null)
+                _callback(this);
+        }
+
+        internal void SetComplete() {
+            _completed = true;
+        }
+
+        /*
+         * Helper method to process completions
+         */
+        internal void Complete(bool synchronous, Object result, Exception error, RequestNotificationStatus status) {
+            if (Volatile.Read(ref _threadWhichStartedOperation) == Thread.CurrentThread) {
+                // If we're calling Complete on the same thread which kicked off the operation, then
+                // we ignore the 'synchronous' value that the caller provided to us since we know
+                // for a fact that this is really a synchronous completion. This is only checked if
+                // the caller calls the MarkCallToBeginMethod* routines below.
+                synchronous = true;
+            }
+
+            _completed              = true;
+            _completedSynchronously = synchronous;
+            _result                 = result;
+            _error                  = error;
+            _status                 = status;
+
+            if (_callback != null)
+                _callback(this);
+        }
+
+        internal void Complete(bool synchronous, Object result, Exception error) {
+            Complete(synchronous, result, error, RequestNotificationStatus.Continue);
+        }
+
+
+        /*
+         * Helper method to implement End call to async method
+         */
+        internal Object End() {
+            if (_error != null)
+                throw new HttpException(null, _error);
+
+            return _result;
+        }
+
+        // If the caller needs to invoke an asynchronous method where the only way of knowing whether the
+        // method actually completed synchronously is to inspect which thread the callback was invoked on,
+        // then the caller should surround the asynchronous call with calls to the below Started / Completed
+        // methods. The callback can compare the captured thread against the current thread to see if the
+        // completion was synchronous. The caller calls the Completed method when unwinding so that the
+        // captured thread can be cleared out, preventing an asynchronous invocation on the same thread
+        // from being mistaken for a synchronous invocation.
+
+        internal void MarkCallToBeginMethodStarted() {
+            Thread originalThread = Interlocked.CompareExchange(ref _threadWhichStartedOperation, Thread.CurrentThread, null);
+            Debug.Assert(originalThread == null, "Another thread already called MarkCallToBeginMethodStarted.");
+        }
+
+        internal void MarkCallToBeginMethodCompleted() {
+            Thread originalThread = Interlocked.Exchange(ref _threadWhichStartedOperation, null);
+            Debug.Assert(originalThread == Thread.CurrentThread, "This thread did not call MarkCallToBeginMethodStarted.");
+        }
+
+        //
+        // Properties that are not part of IAsyncResult
+        //
+
+        internal Exception   Error { get { return _error;}}
+
+        internal RequestNotificationStatus Status {
+            get {
+                return _status;
+            }
+        }
+
+        //
+        // IAsyncResult implementation
+        //
+
+        public bool         IsCompleted { get { return _completed;}}
+        public bool         CompletedSynchronously { get { return _completedSynchronously;}}
+        public Object       AsyncState { get { return _asyncState;}}
+        public WaitHandle   AsyncWaitHandle { get { return null;}} // wait not supported
+    }
+
+}