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
457 lines
14 KiB
C#
457 lines
14 KiB
C#
//-----------------------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
namespace System.ServiceModel.Channels
|
|
{
|
|
using System.Runtime;
|
|
using System.Threading;
|
|
|
|
enum LifetimeState
|
|
{
|
|
Opened,
|
|
Closing,
|
|
Closed
|
|
}
|
|
|
|
class LifetimeManager
|
|
{
|
|
#if DEBUG_EXPENSIVE
|
|
StackTrace closeStack;
|
|
#endif
|
|
bool aborted;
|
|
int busyCount;
|
|
ICommunicationWaiter busyWaiter;
|
|
int busyWaiterCount;
|
|
object mutex;
|
|
LifetimeState state;
|
|
|
|
public LifetimeManager(object mutex)
|
|
{
|
|
this.mutex = mutex;
|
|
this.state = LifetimeState.Opened;
|
|
}
|
|
|
|
public int BusyCount
|
|
{
|
|
get { return this.busyCount; }
|
|
}
|
|
|
|
protected LifetimeState State
|
|
{
|
|
get { return this.state; }
|
|
}
|
|
|
|
protected object ThisLock
|
|
{
|
|
get { return this.mutex; }
|
|
}
|
|
|
|
public void Abort()
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
if (this.State == LifetimeState.Closed || this.aborted)
|
|
return;
|
|
#if DEBUG_EXPENSIVE
|
|
if (closeStack == null)
|
|
closeStack = new StackTrace();
|
|
#endif
|
|
this.aborted = true;
|
|
this.state = LifetimeState.Closing;
|
|
}
|
|
|
|
this.OnAbort();
|
|
this.state = LifetimeState.Closed;
|
|
}
|
|
|
|
void ThrowIfNotOpened()
|
|
{
|
|
if (!this.aborted && this.state != LifetimeState.Opened)
|
|
{
|
|
#if DEBUG_EXPENSIVE
|
|
String originalStack = closeStack.ToString().Replace("\r\n", "\r\n ");
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ObjectDisposedException(this.GetType().ToString() + ", Object already closed:\r\n " + originalStack));
|
|
#else
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ObjectDisposedException(this.GetType().ToString()));
|
|
#endif
|
|
}
|
|
}
|
|
|
|
public IAsyncResult BeginClose(TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
this.ThrowIfNotOpened();
|
|
#if DEBUG_EXPENSIVE
|
|
if (closeStack == null)
|
|
closeStack = new StackTrace();
|
|
#endif
|
|
this.state = LifetimeState.Closing;
|
|
}
|
|
|
|
return this.OnBeginClose(timeout, callback, state);
|
|
}
|
|
|
|
public void Close(TimeSpan timeout)
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
this.ThrowIfNotOpened();
|
|
#if DEBUG_EXPENSIVE
|
|
if (closeStack == null)
|
|
closeStack = new StackTrace();
|
|
#endif
|
|
this.state = LifetimeState.Closing;
|
|
}
|
|
|
|
this.OnClose(timeout);
|
|
this.state = LifetimeState.Closed;
|
|
}
|
|
|
|
CommunicationWaitResult CloseCore(TimeSpan timeout, bool aborting)
|
|
{
|
|
ICommunicationWaiter busyWaiter = null;
|
|
CommunicationWaitResult result = CommunicationWaitResult.Succeeded;
|
|
|
|
lock (this.ThisLock)
|
|
{
|
|
if (this.busyCount > 0)
|
|
{
|
|
if (this.busyWaiter != null)
|
|
{
|
|
if (!aborting && this.aborted)
|
|
return CommunicationWaitResult.Aborted;
|
|
busyWaiter = this.busyWaiter;
|
|
}
|
|
else
|
|
{
|
|
busyWaiter = new SyncCommunicationWaiter(this.ThisLock);
|
|
this.busyWaiter = busyWaiter;
|
|
}
|
|
Interlocked.Increment(ref busyWaiterCount);
|
|
}
|
|
}
|
|
|
|
if (busyWaiter != null)
|
|
{
|
|
result = busyWaiter.Wait(timeout, aborting);
|
|
if (Interlocked.Decrement(ref busyWaiterCount) == 0)
|
|
{
|
|
busyWaiter.Dispose();
|
|
this.busyWaiter = null;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
protected void DecrementBusyCount()
|
|
{
|
|
ICommunicationWaiter busyWaiter = null;
|
|
bool empty = false;
|
|
|
|
lock (this.ThisLock)
|
|
{
|
|
if (this.busyCount <= 0)
|
|
{
|
|
throw Fx.AssertAndThrow("LifetimeManager.DecrementBusyCount: (this.busyCount > 0)");
|
|
}
|
|
if (--this.busyCount == 0)
|
|
{
|
|
if (this.busyWaiter != null)
|
|
{
|
|
busyWaiter = this.busyWaiter;
|
|
Interlocked.Increment(ref this.busyWaiterCount);
|
|
}
|
|
empty = true;
|
|
}
|
|
}
|
|
|
|
if (busyWaiter != null)
|
|
{
|
|
busyWaiter.Signal();
|
|
if (Interlocked.Decrement(ref this.busyWaiterCount) == 0)
|
|
{
|
|
busyWaiter.Dispose();
|
|
this.busyWaiter = null;
|
|
}
|
|
}
|
|
|
|
if (empty && this.State == LifetimeState.Opened)
|
|
OnEmpty();
|
|
}
|
|
|
|
public void EndClose(IAsyncResult result)
|
|
{
|
|
this.OnEndClose(result);
|
|
this.state = LifetimeState.Closed;
|
|
}
|
|
|
|
protected virtual void IncrementBusyCount()
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
Fx.Assert(this.State == LifetimeState.Opened, "LifetimeManager.IncrementBusyCount: (this.State == LifetimeState.Opened)");
|
|
this.busyCount++;
|
|
}
|
|
}
|
|
|
|
protected virtual void IncrementBusyCountWithoutLock()
|
|
{
|
|
Fx.Assert(this.State == LifetimeState.Opened, "LifetimeManager.IncrementBusyCountWithoutLock: (this.State == LifetimeState.Opened)");
|
|
this.busyCount++;
|
|
}
|
|
|
|
protected virtual void OnAbort()
|
|
{
|
|
// We have decided not to make this configurable
|
|
CloseCore(TimeSpan.FromSeconds(1), true);
|
|
}
|
|
|
|
protected virtual IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state)
|
|
{
|
|
CloseCommunicationAsyncResult closeResult = null;
|
|
|
|
lock (this.ThisLock)
|
|
{
|
|
if (this.busyCount > 0)
|
|
{
|
|
if (this.busyWaiter != null)
|
|
{
|
|
Fx.Assert(this.aborted, "LifetimeManager.OnBeginClose: (this.aborted == true)");
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ObjectDisposedException(this.GetType().ToString()));
|
|
}
|
|
else
|
|
{
|
|
closeResult = new CloseCommunicationAsyncResult(timeout, callback, state, this.ThisLock);
|
|
Fx.Assert(this.busyWaiter == null, "LifetimeManager.OnBeginClose: (this.busyWaiter == null)");
|
|
this.busyWaiter = closeResult;
|
|
Interlocked.Increment(ref this.busyWaiterCount);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (closeResult != null)
|
|
{
|
|
return closeResult;
|
|
}
|
|
else
|
|
{
|
|
return new CompletedAsyncResult(callback, state);
|
|
}
|
|
}
|
|
|
|
protected virtual void OnClose(TimeSpan timeout)
|
|
{
|
|
switch (CloseCore(timeout, false))
|
|
{
|
|
case CommunicationWaitResult.Expired:
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TimeoutException(SR.GetString(SR.SFxCloseTimedOut1, timeout)));
|
|
case CommunicationWaitResult.Aborted:
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ObjectDisposedException(this.GetType().ToString()));
|
|
}
|
|
}
|
|
|
|
protected virtual void OnEmpty()
|
|
{
|
|
}
|
|
|
|
protected virtual void OnEndClose(IAsyncResult result)
|
|
{
|
|
if (result is CloseCommunicationAsyncResult)
|
|
{
|
|
CloseCommunicationAsyncResult.End(result);
|
|
if (Interlocked.Decrement(ref this.busyWaiterCount) == 0)
|
|
{
|
|
this.busyWaiter.Dispose();
|
|
this.busyWaiter = null;
|
|
}
|
|
}
|
|
else
|
|
CompletedAsyncResult.End(result);
|
|
}
|
|
}
|
|
|
|
enum CommunicationWaitResult
|
|
{
|
|
Waiting,
|
|
Succeeded,
|
|
Expired,
|
|
Aborted
|
|
}
|
|
|
|
interface ICommunicationWaiter : IDisposable
|
|
{
|
|
void Signal();
|
|
CommunicationWaitResult Wait(TimeSpan timeout, bool aborting);
|
|
}
|
|
|
|
class CloseCommunicationAsyncResult : AsyncResult, ICommunicationWaiter
|
|
{
|
|
object mutex;
|
|
CommunicationWaitResult result;
|
|
IOThreadTimer timer;
|
|
TimeoutHelper timeoutHelper;
|
|
TimeSpan timeout;
|
|
|
|
public CloseCommunicationAsyncResult(TimeSpan timeout, AsyncCallback callback, object state, object mutex)
|
|
: base(callback, state)
|
|
{
|
|
this.timeout = timeout;
|
|
this.timeoutHelper = new TimeoutHelper(timeout);
|
|
this.mutex = mutex;
|
|
|
|
if (timeout < TimeSpan.Zero)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TimeoutException(SR.GetString(SR.SFxCloseTimedOut1, timeout)));
|
|
|
|
this.timer = new IOThreadTimer(new Action<object>(TimeoutCallback), this, true);
|
|
this.timer.Set(timeout);
|
|
}
|
|
|
|
object ThisLock
|
|
{
|
|
get { return mutex; }
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
}
|
|
|
|
public static void End(IAsyncResult result)
|
|
{
|
|
AsyncResult.End<CloseCommunicationAsyncResult>(result);
|
|
}
|
|
|
|
public void Signal()
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
if (this.result != CommunicationWaitResult.Waiting)
|
|
return;
|
|
this.result = CommunicationWaitResult.Succeeded;
|
|
}
|
|
this.timer.Cancel();
|
|
this.Complete(false);
|
|
}
|
|
|
|
void Timeout()
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
if (this.result != CommunicationWaitResult.Waiting)
|
|
return;
|
|
this.result = CommunicationWaitResult.Expired;
|
|
}
|
|
this.Complete(false, new TimeoutException(SR.GetString(SR.SFxCloseTimedOut1, this.timeout)));
|
|
}
|
|
|
|
static void TimeoutCallback(object state)
|
|
{
|
|
CloseCommunicationAsyncResult closeResult = (CloseCommunicationAsyncResult)state;
|
|
closeResult.Timeout();
|
|
}
|
|
|
|
public CommunicationWaitResult Wait(TimeSpan timeout, bool aborting)
|
|
{
|
|
if (timeout < TimeSpan.Zero)
|
|
{
|
|
return CommunicationWaitResult.Expired;
|
|
}
|
|
|
|
// Synchronous Wait on AsyncResult should only be called in Abort code-path
|
|
Fx.Assert(aborting, "CloseCommunicationAsyncResult.Wait: (aborting == true)");
|
|
|
|
lock (this.ThisLock)
|
|
{
|
|
if (this.result != CommunicationWaitResult.Waiting)
|
|
{
|
|
return this.result;
|
|
}
|
|
this.result = CommunicationWaitResult.Aborted;
|
|
}
|
|
this.timer.Cancel();
|
|
|
|
TimeoutHelper.WaitOne(this.AsyncWaitHandle, timeout);
|
|
|
|
this.Complete(false, new ObjectDisposedException(this.GetType().ToString()));
|
|
return this.result;
|
|
}
|
|
}
|
|
|
|
internal class SyncCommunicationWaiter : ICommunicationWaiter
|
|
{
|
|
bool closed;
|
|
object mutex;
|
|
CommunicationWaitResult result;
|
|
ManualResetEvent waitHandle;
|
|
|
|
public SyncCommunicationWaiter(object mutex)
|
|
{
|
|
this.mutex = mutex;
|
|
this.waitHandle = new ManualResetEvent(false);
|
|
}
|
|
|
|
object ThisLock
|
|
{
|
|
get { return this.mutex; }
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
if (this.closed)
|
|
return;
|
|
this.closed = true;
|
|
this.waitHandle.Close();
|
|
}
|
|
}
|
|
|
|
public void Signal()
|
|
{
|
|
lock (this.ThisLock)
|
|
{
|
|
if (this.closed)
|
|
return;
|
|
this.waitHandle.Set();
|
|
}
|
|
}
|
|
|
|
public CommunicationWaitResult Wait(TimeSpan timeout, bool aborting)
|
|
{
|
|
if (this.closed)
|
|
{
|
|
return CommunicationWaitResult.Aborted;
|
|
}
|
|
if (timeout < TimeSpan.Zero)
|
|
{
|
|
return CommunicationWaitResult.Expired;
|
|
}
|
|
|
|
if (aborting)
|
|
{
|
|
this.result = CommunicationWaitResult.Aborted;
|
|
}
|
|
|
|
bool expired = !TimeoutHelper.WaitOne(this.waitHandle, timeout);
|
|
|
|
lock (this.ThisLock)
|
|
{
|
|
if (this.result == CommunicationWaitResult.Waiting)
|
|
{
|
|
this.result = (expired ? CommunicationWaitResult.Expired : CommunicationWaitResult.Succeeded);
|
|
}
|
|
}
|
|
|
|
lock (this.ThisLock)
|
|
{
|
|
if (!this.closed)
|
|
this.waitHandle.Set(); // unblock other waiters if there are any
|
|
}
|
|
|
|
return this.result;
|
|
}
|
|
}
|
|
}
|