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);
}
CommunicationWaitResult AbortCore(CancellationToken token)
{
ICommunicationWaiter busyWaiter = null;
CommunicationWaitResult result = CommunicationWaitResult.Succeeded;
lock (ThisLock)
{
if (_busyCount > 0)
{
if (_busyWaiter != null)
{
busyWaiter = _busyWaiter;
}
else
{
busyWaiter = new AsyncCommunicationWaiter(ThisLock);
_busyWaiter = busyWaiter;
}
Interlocked.Increment(ref _busyWaiterCount);
}
}
if (busyWaiter != null)
{
result = busyWaiter.Wait(true, token);
if (Interlocked.Decrement(ref _busyWaiterCount) == 0)
{
busyWaiter.Dispose();
_busyWaiter = null;
}
}
return(result);
}
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 flag = !TimeoutHelper.WaitOne(this.waitHandle, timeout);
lock (this.ThisLock)
{
if (this.result == CommunicationWaitResult.Waiting)
{
this.result = flag ? CommunicationWaitResult.Expired : CommunicationWaitResult.Succeeded;
}
}
lock (this.ThisLock)
{
if (!this.closed)
{
this.waitHandle.Set();
}
}
return this.result;
}
public void CloseInput(TimeSpan timeout)
{
SyncCommunicationWaiter waiter = null;
lock (base.ThisLock)
{
if (this.activityCount > 0)
{
waiter = new SyncCommunicationWaiter(base.ThisLock);
ICommunicationWaiter activityWaiter = this.activityWaiter;
this.activityWaiter = waiter;
Interlocked.Increment(ref this.activityWaiterCount);
}
}
if (waiter != null)
{
CommunicationWaitResult result = waiter.Wait(timeout, false);
if (Interlocked.Decrement(ref this.activityWaiterCount) == 0)
{
waiter.Dispose();
this.activityWaiter = null;
}
switch (result)
{
case CommunicationWaitResult.Expired:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TimeoutException(System.ServiceModel.SR.GetString("SfxCloseTimedOutWaitingForDispatchToComplete")));
case CommunicationWaitResult.Aborted:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ObjectDisposedException(base.GetType().ToString()));
}
}
}
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)));
}
private void Timeout()
{
lock (this.ThisLock)
{
if (_result != CommunicationWaitResult.Waiting)
{
return;
}
_result = CommunicationWaitResult.Expired;
}
this.Complete(false, new TimeoutException(string.Format(SRServiceModel.SFxCloseTimedOut1, _timeout)));
}
private void Timeout()
{
lock (this.ThisLock)
{
if (this.result != CommunicationWaitResult.Waiting)
{
return;
}
this.result = CommunicationWaitResult.Expired;
}
base.Complete(false, new TimeoutException(System.ServiceModel.SR.GetString("SFxCloseTimedOut1", new object[] { this.timeout })));
}
public void Signal()
{
lock (this.ThisLock)
{
if (this.result != CommunicationWaitResult.Waiting)
{
return;
}
this.result = CommunicationWaitResult.Succeeded;
}
this.timer.Cancel();
base.Complete(false);
}
public void Signal()
{
lock (this.ThisLock)
{
if (_result != CommunicationWaitResult.Waiting)
{
return;
}
_result = CommunicationWaitResult.Succeeded;
}
_timer.Change(TimeSpan.FromMilliseconds(-1), TimeSpan.FromMilliseconds(-1));
this.Complete(false);
}
public CommunicationWaitResult Wait(TimeSpan timeout, bool aborting)
{
if (timeout < TimeSpan.Zero)
{
return CommunicationWaitResult.Expired;
}
lock (this.ThisLock)
{
if (this.result != CommunicationWaitResult.Waiting)
{
return this.result;
}
this.result = CommunicationWaitResult.Aborted;
}
this.timer.Cancel();
TimeoutHelper.WaitOne(base.AsyncWaitHandle, timeout);
base.Complete(false, new ObjectDisposedException(base.GetType().ToString()));
return this.result;
}
public async Task <CommunicationWaitResult> CloseCoreAsync(bool aborting, CancellationToken token)
{
token.ThrowIfCancellationRequested();
ICommunicationWaiter busyWaiter = null;
CommunicationWaitResult result = CommunicationWaitResult.Succeeded;
lock (ThisLock)
{
if (BusyCount > 0)
{
if (_busyWaiter != null)
{
if (!aborting && _aborted)
{
return(CommunicationWaitResult.Aborted);
}
busyWaiter = _busyWaiter;
}
else
{
busyWaiter = new AsyncCommunicationWaiter(ThisLock);
_busyWaiter = busyWaiter;
}
Interlocked.Increment(ref _busyWaiterCount);
}
}
if (busyWaiter != null)
{
result = await busyWaiter.WaitAsync(aborting, token);
if (Interlocked.Decrement(ref _busyWaiterCount) == 0)
{
busyWaiter.Dispose();
_busyWaiter = null;
}
}
return(result);
}
public async Task CloseInputAsync(CancellationToken token)
{
AsyncCommunicationWaiter activityWaiter = null;
lock (ThisLock)
{
if (ActivityCount > 0)
{
activityWaiter = new AsyncCommunicationWaiter(ThisLock);
if (!(_activityWaiter == null))
{
Fx.Assert("ServiceChannelManager.CloseInput: (this.activityWaiter == null)");
}
_activityWaiter = activityWaiter;
Interlocked.Increment(ref _activityWaiterCount);
}
}
if (activityWaiter != null)
{
CommunicationWaitResult result = await activityWaiter.WaitAsync(false, token);
if (Interlocked.Decrement(ref _activityWaiterCount) == 0)
{
activityWaiter.Dispose();
_activityWaiter = null;
}
switch (result)
{
case CommunicationWaitResult.Expired:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TimeoutException(SR.SfxCloseTimedOutWaitingForDispatchToComplete));
case CommunicationWaitResult.Aborted:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ObjectDisposedException(GetType().ToString()));
}
}
}
public void CloseInput(TimeSpan timeout)
{
SyncCommunicationWaiter activityWaiter = null;
lock (this.ThisLock)
{
if (this.activityCount > 0)
{
activityWaiter = new SyncCommunicationWaiter(this.ThisLock);
if (!(this.activityWaiter == null))
{
Fx.Assert("ServiceChannelManager.CloseInput: (this.activityWaiter == null)");
}
this.activityWaiter = activityWaiter;
Interlocked.Increment(ref this.activityWaiterCount);
}
}
if (activityWaiter != null)
{
CommunicationWaitResult result = activityWaiter.Wait(timeout, false);
if (Interlocked.Decrement(ref this.activityWaiterCount) == 0)
{
activityWaiter.Dispose();
this.activityWaiter = null;
}
switch (result)
{
case CommunicationWaitResult.Expired:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TimeoutException(SR.GetString(SR.SfxCloseTimedOutWaitingForDispatchToComplete)));
case CommunicationWaitResult.Aborted:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ObjectDisposedException(this.GetType().ToString()));
}
}
}
public async Task <CommunicationWaitResult> WaitAsync(bool aborting, CancellationToken token)
{
Fx.Assert(token.CanBeCanceled, "CancellationToken must be cancellable");
if (_closed)
{
return(CommunicationWaitResult.Aborted);
}
if (token.IsCancellationRequested)
{
return(CommunicationWaitResult.Expired);
}
if (aborting)
{
_result = CommunicationWaitResult.Aborted;
}
_tcs = new TaskCompletionSource <bool>();
using (token.Register(WaiterTimeout, _tcs))
{
await _tcs.Task;
bool expired = token.IsCancellationRequested;
lock (ThisLock)
{
if (_result == CommunicationWaitResult.Waiting)
{
_result = (expired ? CommunicationWaitResult.Expired : CommunicationWaitResult.Succeeded);
}
}
return(_result);
}
}
public void Signal()
{
lock (this.ThisLock)
{
if (_result != CommunicationWaitResult.Waiting)
return;
_result = CommunicationWaitResult.Succeeded;
}
_timer.Change(TimeSpan.FromMilliseconds(-1), TimeSpan.FromMilliseconds(-1));
this.Complete(false);
}
private void Timeout()
{
lock (this.ThisLock)
{
if (_result != CommunicationWaitResult.Waiting)
return;
_result = CommunicationWaitResult.Expired;
}
this.Complete(false, new TimeoutException(SR.Format(SR.SFxCloseTimedOut1, _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 (_result != CommunicationWaitResult.Waiting)
{
return _result;
}
_result = CommunicationWaitResult.Aborted;
}
_timer.Change(TimeSpan.FromMilliseconds(-1), TimeSpan.FromMilliseconds(-1));
TimeoutHelper.WaitOne(this.AsyncWaitHandle, timeout);
this.Complete(false, new ObjectDisposedException(this.GetType().ToString()));
return _result;
}
public CommunicationWaitResult Wait(TimeSpan timeout, bool aborting)
{
if (_closed)
{
return CommunicationWaitResult.Aborted;
}
if (timeout < TimeSpan.Zero)
{
return CommunicationWaitResult.Expired;
}
if (aborting)
{
_result = CommunicationWaitResult.Aborted;
}
bool expired = !TimeoutHelper.WaitOne(_waitHandle, timeout);
lock (this.ThisLock)
{
if (_result == CommunicationWaitResult.Waiting)
{
_result = (expired ? CommunicationWaitResult.Expired : CommunicationWaitResult.Succeeded);
}
}
lock (this.ThisLock)
{
if (!_closed)
_waitHandle.Set(); // unblock other waiters if there are any
}
return _result;
}
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)));
}
