public static void SafeClose(this ICommunicationObject communicationObject, TimeSpan?timeout = null)
{
try
{
if (communicationObject != null && communicationObject.State != CommunicationState.Closed)
{
if (MessagingUtilities.safeCloseCommunicationObjectCallback == null)
{
MessagingUtilities.safeCloseCommunicationObjectCallback = new AsyncCallback(MessagingUtilities.SafeCloseCommunicationObjectCallback);
}
if (!timeout.HasValue)
{
communicationObject.BeginClose(MessagingUtilities.safeCloseCommunicationObjectCallback, communicationObject);
}
else
{
communicationObject.BeginClose(timeout.Value, MessagingUtilities.safeCloseCommunicationObjectCallback, communicationObject);
}
}
}
catch (Exception exception1)
{
Exception exception = exception1;
if (Fx.IsFatal(exception))
{
throw;
}
Fx.Exception.TraceHandled(exception, "MessagingUtilities.SafeClose(CommunicationObject)", null);
if (communicationObject != null)
{
communicationObject.Abort();
}
}
}
public CloseAsyncResult(
ICommunicationObject communicationObject,
bool sharedInnerListener,
TimeSpan timeout,
AsyncCallback callback,
object state
) : base(callback, state)
{
_communicationObject = communicationObject;
if (_communicationObject == null || sharedInnerListener)
{
Complete(true);
return;
}
IAsyncResult result = _communicationObject.BeginClose(
timeout,
_onCloseComplete,
this
);
if (result.CompletedSynchronously)
{
_communicationObject.EndClose(result);
Complete(true);
}
}
// Helper used to close another CommunicationObject "owned" by the current one.
// It is used to propagate the use of either the synchronous or asynchronous methods
internal async Task CloseOtherAsync(ICommunicationObject other, TimeSpan timeout)
{
// If the current object is being closed synchronously, use the synchronous
// close path for the other object.
if (_isSynchronousClose)
{
await TaskHelpers.CallActionAsync(other.Close, timeout);
}
else
{
await Task.Factory.FromAsync(other.BeginClose(timeout, callback: null, state: null), other.EndClose);
}
}
/// <summary>
/// Desliga a comunicação.
/// </summary>
/// <param name="communicationObject"></param>
public static void Shutdown(ICommunicationObject communicationObject)
{
if (communicationObject != null)
{
try
{
communicationObject.BeginClose(new AsyncCallback(CommunicationHelpers.ShutdownCallback), communicationObject);
}
catch (TimeoutException)
{
communicationObject.Abort();
}
catch (CommunicationException)
{
communicationObject.Abort();
}
}
}
/// <summary>
/// Desliga a comunicação com o objeto informado.
/// </summary>
/// <param name="communicationObject"></param>
private void ShutdownCommunicationObject(ICommunicationObject communicationObject)
{
if (communicationObject != null)
{
try
{
communicationObject.BeginClose(new AsyncCallback(ShutdownCommunicationObjectCallback), communicationObject);
}
catch (System.TimeoutException)
{
communicationObject.Abort();
}
catch (CommunicationException)
{
communicationObject.Abort();
}
catch (NullReferenceException)
{
communicationObject.Abort();
}
}
}
/// <summary>
/// Helper class to async close ICommunicationObject
/// </summary>
/// <param name="obj">indicating the object</param>
public static void AsyncCloseICommunicationObject(ICommunicationObject obj)
{
try
{
if (obj == null)
{
return;
}
if (obj.State == CommunicationState.Faulted)
{
obj.Abort();
}
else
{
obj.BeginClose(callbackToCloseChannel, obj);
}
}
catch (Exception)
{
obj.Abort();
}
}
protected virtual IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state)
{
return(inner.BeginClose(timeout, callback, state));
}
// Helper used to close another CommunicationObject "owned" by the current one.
// It is used to propagate the use of either the synchronous or asynchronous methods
internal async Task CloseOtherAsync(ICommunicationObject other, TimeSpan timeout)
{
// If the current object is being closed synchronously, use the synchronous
// close path for the other object.
if (_isSynchronousClose)
{
await TaskHelpers.CallActionAsync<TimeSpan>(other.Close, timeout);
}
else
{
await Task.Factory.FromAsync(other.BeginClose(timeout, callback: null, state: null), other.EndClose);
}
}
public System.IAsyncResult BeginClose(System.TimeSpan timeout, System.AsyncCallback callback, object state)
{
return(_communicationObject.BeginClose(timeout, callback, state));
}
/// <summary>
/// Asynchronously closes the connection of the proxy.
/// </summary>
/// <exception cref="ArgumentNullException">The <paramref name="communicationObject"/> is null.</exception>
public static Task CloseAsync(this ICommunicationObject communicationObject)
{
_ = communicationObject ?? throw new ArgumentNullException(nameof(communicationObject));
return(Task.Factory.FromAsync(communicationObject.BeginClose(null, null), communicationObject.EndClose));
}