mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
104 lines
4.5 KiB
C#
104 lines
4.5 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="AsyncResultBase.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
/*
|
|
* IAsyncResult for asynchronous reads.
|
|
*
|
|
* Copyright (c) 2010 Microsoft Corporation
|
|
*/
|
|
|
|
namespace System.Web.Hosting {
|
|
using System;
|
|
using System.Runtime.ExceptionServices;
|
|
using System.Threading;
|
|
using System.Web.Util;
|
|
|
|
internal abstract class AsyncResultBase : IAsyncResult {
|
|
private ManualResetEventSlim _mre; // unlike ManualResetEvent, this creates a kernel object lazily
|
|
private AsyncCallback _callback;
|
|
private Object _asyncState;
|
|
private volatile bool _completed;
|
|
private volatile bool _completedSynchronously;
|
|
private volatile int _hresult;
|
|
private Thread _threadWhichStartedOperation;
|
|
private volatile ExceptionDispatchInfo _error;
|
|
|
|
protected AsyncResultBase(AsyncCallback cb, Object state) {
|
|
_callback = cb;
|
|
_asyncState = state;
|
|
_mre = new ManualResetEventSlim();
|
|
}
|
|
|
|
internal abstract void Complete(int bytesCompleted, int hresult, IntPtr pAsyncCompletionContext, bool synchronous);
|
|
|
|
protected void Complete(int hresult, bool synchronous) {
|
|
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, which only occurs in
|
|
// the Classic Mode pipeline.
|
|
synchronous = true;
|
|
}
|
|
|
|
_hresult = hresult;
|
|
_completed = true;
|
|
_completedSynchronously = synchronous;
|
|
_mre.Set();
|
|
|
|
if (_callback != null)
|
|
_callback(this);
|
|
}
|
|
|
|
// 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.");
|
|
}
|
|
|
|
internal void ReleaseWaitHandleWhenSignaled() {
|
|
try {
|
|
_mre.Wait();
|
|
}
|
|
finally {
|
|
_mre.Dispose();
|
|
}
|
|
}
|
|
|
|
internal void SetError(Exception error) {
|
|
Debug.Assert(error != null);
|
|
_error = ExceptionDispatchInfo.Capture(error);
|
|
}
|
|
|
|
// Properties that are not part of IAsyncResult
|
|
//
|
|
|
|
internal int HResult { get { return _hresult; } set { _hresult = value; } }
|
|
internal ExceptionDispatchInfo Error { get { return _error; } }
|
|
|
|
//
|
|
// 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 _mre.WaitHandle; } } // wait not supported
|
|
}
|
|
}
|