internal static void CloseNoThrow(IConnection connection, TimeSpan timeout)
{
bool success = false;
try
{
connection.Close(timeout, false);
success = true;
}
catch (TimeoutException e)
{
if (TD.CloseTimeoutIsEnabled())
{
TD.CloseTimeout(e.Message);
}
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
}
catch (CommunicationException e)
{
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
}
finally
{
if (!success)
{
connection.Abort();
}
}
}
void OnClose(TimeSpan timeout)
{
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
foreach (EndpointConnectionPool pool in endpointPools.Values)
{
try
{
pool.Close(timeoutHelper.RemainingTime());
}
catch (CommunicationException exception)
{
if (DiagnosticUtility.ShouldTraceError)
{
TraceUtility.TraceEvent(TraceEventType.Error, TraceCode.ConnectionPoolCloseException, SR.GetString(SR.TraceCodeConnectionPoolCloseException), this, exception);
}
}
catch (TimeoutException exception)
{
if (TD.CloseTimeoutIsEnabled())
{
TD.CloseTimeout(exception.Message);
}
if (DiagnosticUtility.ShouldTraceError)
{
TraceUtility.TraceEvent(TraceEventType.Error, TraceCode.ConnectionPoolCloseException, SR.GetString(SR.TraceCodeConnectionPoolCloseException), this, exception);
}
}
}
endpointPools.Clear();
}
protected override void OnClose(TimeSpan timeout)
{
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
TChannel[] channels = GetChannels();
for (int i = 0; i < channels.Length; i++)
{
bool success = false;
try
{
channels[i].Close(timeoutHelper.RemainingTime());
success = true;
}
catch (CommunicationException e)
{
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
}
catch (TimeoutException e)
{
if (TD.CloseTimeoutIsEnabled())
{
TD.CloseTimeout(e.Message);
}
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
}
finally
{
if (!success)
{
channels[i].Abort();
}
}
}
}
protected async Task CloseOutputSessionAsync(TimeSpan timeout)
{
ThrowIfNotOpened();
ThrowIfFaulted();
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
// If timeout == TimeSpan.MaxValue, then we want to pass Timeout.Infinite as
// SemaphoreSlim doesn't accept timeouts > Int32.MaxValue.
// Using TimeoutHelper.RemainingTime() would yield a value less than TimeSpan.MaxValue
// and would result in the value Int32.MaxValue so we must use the original timeout specified.
if (!await _sendLock.WaitAsync(TimeoutHelper.ToMilliseconds(timeout)))
{
if (TD.CloseTimeoutIsEnabled())
{
TD.CloseTimeout(SR.Format(SR.CloseTimedOut, timeout));
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TimeoutException(
SR.Format(SR.CloseTimedOut, timeout),
TimeoutHelper.CreateEnterTimedOutException(timeout)));
}
try
{
// check again in case the previous send faulted while we were waiting for the lock
ThrowIfFaulted();
// we're synchronized by sendLock here
if (_isOutputSessionClosed)
{
return;
}
_isOutputSessionClosed = true;
bool shouldFault = true;
try
{
await this.CloseOutputSessionCoreAsync(timeout);
this.OnOutputSessionClosed(ref timeoutHelper);
shouldFault = false;
}
finally
{
if (shouldFault)
{
this.Fault();
}
}
}
finally
{
_sendLock.Release();
}
}
protected void CloseOutputSession(TimeSpan timeout)
{
ThrowIfNotOpened();
ThrowIfFaulted();
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
if (!this.sendLock.TryEnter(timeoutHelper.RemainingTime()))
{
if (TD.CloseTimeoutIsEnabled())
{
TD.CloseTimeout(SR.GetString(SR.CloseTimedOut, timeout));
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TimeoutException(
SR.GetString(SR.CloseTimedOut, timeout),
ThreadNeutralSemaphore.CreateEnterTimedOutException(timeout)));
}
try
{
// check again in case the previous send faulted while we were waiting for the lock
ThrowIfFaulted();
// we're synchronized by sendLock here
if (this.isOutputSessionClosed)
{
return;
}
this.isOutputSessionClosed = true;
bool shouldFault = true;
try
{
this.CloseOutputSessionCore(timeout);
this.OnOutputSessionClosed(ref timeoutHelper);
shouldFault = false;
}
finally
{
if (shouldFault)
{
this.Fault();
}
}
}
finally
{
this.sendLock.Exit();
}
}
// for cached connections -- try to shut down gracefully if possible
public void CloseFromPool(TimeSpan timeout)
{
try
{
Close(timeout);
}
catch (CommunicationException communicationException)
{
DiagnosticUtility.TraceHandledException(communicationException, TraceEventType.Information);
}
catch (TimeoutException timeoutException)
{
if (TD.CloseTimeoutIsEnabled())
{
TD.CloseTimeout(timeoutException.Message);
}
DiagnosticUtility.TraceHandledException(timeoutException, TraceEventType.Information);
}
}
void IDisposable.Dispose()
{
bool success = false;
RequestContext thisContext;
lock (this.thisLock)
{
if (this.context == null)
{
return;
}
thisContext = this.context;
this.context = null;
}
try
{
thisContext.Close();
success = true;
}
catch (CommunicationException e)
{
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
}
catch (TimeoutException e)
{
if (TD.CloseTimeoutIsEnabled())
{
TD.CloseTimeout(e.Message);
}
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
}
finally
{
if (!success)
{
thisContext.Abort();
}
}
}
void OnReceive(IAsyncResult result)
{
IDuplexSessionChannel channel = (IDuplexSessionChannel)result.AsyncState;
bool success = false;
try
{
Message message = channel.EndReceive(result);
if (message == null)
{
channel.Close(this.channelPool.IdleTimeout);
success = true;
}
else
{
message.Close();
}
}
catch (CommunicationException e)
{
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
}
catch (TimeoutException e)
{
if (TD.CloseTimeoutIsEnabled())
{
TD.CloseTimeout(e.Message);
}
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
}
finally
{
if (!success)
{
channel.Abort();
}
}
}
void IDisposable.Dispose()
{
bool success = false;
RequestContext thisContext;
lock (_thisLock)
{
if (_context == null)
{
return;
}
thisContext = _context;
_context = null;
}
try
{
thisContext.Close();
success = true;
}
catch (CommunicationException)
{
}
catch (TimeoutException e)
{
if (TD.CloseTimeoutIsEnabled())
{
TD.CloseTimeout(e.Message);
}
}
finally
{
if (!success)
{
thisContext.Abort();
}
}
}
private void OnClose(TimeSpan timeout)
{
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
foreach (EndpointConnectionPool pool in _endpointPools.Values)
{
try
{
pool.Close(timeoutHelper.RemainingTime());
}
catch (CommunicationException)
{
}
catch (TimeoutException exception)
{
if (TD.CloseTimeoutIsEnabled())
{
TD.CloseTimeout(exception.Message);
}
}
}
_endpointPools.Clear();
}