Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
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
2016-05-03 00:07:37 +02:00

284 lines
9.1 KiB
C#

//----------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//----------------------------------------------------------------
namespace System.Runtime
{
using System;
using System.Collections.Generic;
using System.Security;
using System.Threading;
[Fx.Tag.SynchronizationPrimitive(Fx.Tag.BlocksUsing.MonitorWait, SupportsAsync = true, ReleaseMethod = "Set")]
class AsyncWaitHandle
{
static Action<object> timerCompleteCallback;
List<AsyncWaiter> asyncWaiters;
bool isSignaled;
EventResetMode resetMode;
[Fx.Tag.SynchronizationObject(Kind = Fx.Tag.SynchronizationKind.MonitorWait)]
object syncObject;
int syncWaiterCount;
public AsyncWaitHandle()
: this(EventResetMode.AutoReset)
{
}
public AsyncWaitHandle(EventResetMode resetMode)
{
this.resetMode = resetMode;
this.syncObject = new object();
}
public bool WaitAsync(Action<object, TimeoutException> callback, object state, TimeSpan timeout)
{
if (!this.isSignaled || (this.isSignaled && this.resetMode == EventResetMode.AutoReset))
{
lock (syncObject)
{
if (this.isSignaled && this.resetMode == EventResetMode.AutoReset)
{
this.isSignaled = false;
}
else if (!this.isSignaled)
{
AsyncWaiter waiter = new AsyncWaiter(this, callback, state);
if (this.asyncWaiters == null)
{
this.asyncWaiters = new List<AsyncWaiter>();
}
this.asyncWaiters.Add(waiter);
if (timeout != TimeSpan.MaxValue)
{
if (timerCompleteCallback == null)
{
timerCompleteCallback = new Action<object>(OnTimerComplete);
}
waiter.SetTimer(timerCompleteCallback, waiter, timeout);
}
return false;
}
}
}
return true;
}
static void OnTimerComplete(object state)
{
AsyncWaiter waiter = (AsyncWaiter)state;
AsyncWaitHandle thisPtr = waiter.Parent;
bool callWaiter = false;
lock (thisPtr.syncObject)
{
// If still in the waiting list (that means it hasn't been signaled)
if (thisPtr.asyncWaiters != null && thisPtr.asyncWaiters.Remove(waiter))
{
waiter.TimedOut = true;
callWaiter = true;
}
}
waiter.CancelTimer();
if (callWaiter)
{
waiter.Call();
}
}
[Fx.Tag.Blocking]
public bool Wait(TimeSpan timeout)
{
if (!this.isSignaled || (this.isSignaled && this.resetMode == EventResetMode.AutoReset))
{
lock (syncObject)
{
if (this.isSignaled && this.resetMode == EventResetMode.AutoReset)
{
this.isSignaled = false;
}
else if (!this.isSignaled)
{
bool decrementRequired = false;
try
{
try
{
}
finally
{
this.syncWaiterCount++;
decrementRequired = true;
}
if (timeout == TimeSpan.MaxValue)
{
if (!Monitor.Wait(syncObject, Timeout.Infinite))
{
return false;
}
}
else
{
if (!Monitor.Wait(syncObject, timeout))
{
return false;
}
}
}
finally
{
if (decrementRequired)
{
this.syncWaiterCount--;
}
}
}
}
}
return true;
}
public void Set()
{
List<AsyncWaiter> toCallList = null;
AsyncWaiter toCall = null;
if (!this.isSignaled)
{
lock (syncObject)
{
if (!this.isSignaled)
{
if (this.resetMode == EventResetMode.ManualReset)
{
this.isSignaled = true;
Monitor.PulseAll(syncObject);
toCallList = this.asyncWaiters;
this.asyncWaiters = null;
}
else
{
if (this.syncWaiterCount > 0)
{
Monitor.Pulse(syncObject);
}
else if (this.asyncWaiters != null && this.asyncWaiters.Count > 0)
{
toCall = this.asyncWaiters[0];
this.asyncWaiters.RemoveAt(0);
}
else
{
this.isSignaled = true;
}
}
}
}
}
if (toCallList != null)
{
foreach (AsyncWaiter waiter in toCallList)
{
waiter.CancelTimer();
waiter.Call();
}
}
if (toCall != null)
{
toCall.CancelTimer();
toCall.Call();
}
}
public void Reset()
{
// Doesn't matter if this changes during processing of another method
this.isSignaled = false;
}
class AsyncWaiter : ActionItem
{
[Fx.Tag.SecurityNote(Critical = "Store the delegate to be invoked")]
[SecurityCritical]
Action<object, TimeoutException> callback;
[Fx.Tag.SecurityNote(Critical = "Stores the state object to be passed to the callback")]
[SecurityCritical]
object state;
IOThreadTimer timer;
TimeSpan originalTimeout;
[Fx.Tag.SecurityNote(Critical = "Access critical members", Safe = "Doesn't leak information")]
[SecuritySafeCritical]
public AsyncWaiter(AsyncWaitHandle parent, Action<object, TimeoutException> callback, object state)
{
this.Parent = parent;
this.callback = callback;
this.state = state;
}
public AsyncWaitHandle Parent
{
get;
private set;
}
public bool TimedOut
{
get;
set;
}
[Fx.Tag.SecurityNote(Critical = "Calls into critical method Schedule", Safe = "Invokes the given delegate under the current context")]
[SecuritySafeCritical]
public void Call()
{
Schedule();
}
[Fx.Tag.SecurityNote(Critical = "Overriding an inherited critical method, access critical members")]
[SecurityCritical]
protected override void Invoke()
{
this.callback(this.state,
this.TimedOut ? new TimeoutException(InternalSR.TimeoutOnOperation(this.originalTimeout)) : null);
}
public void SetTimer(Action<object> callback, object state, TimeSpan timeout)
{
if (this.timer != null)
{
throw Fx.Exception.AsError(new InvalidOperationException(InternalSR.MustCancelOldTimer));
}
this.originalTimeout = timeout;
this.timer = new IOThreadTimer(callback, state, false);
this.timer.Set(timeout);
}
public void CancelTimer()
{
if (this.timer != null)
{
this.timer.Cancel();
this.timer = null;
}
}
}
}
}