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))); }