private void HandleOnCallBegin(InvokeInfo invokeInfo)
{
this.OnCallBegin(this, new OnCallBeginHandlerArguments
{
ServiceType = _originalServiceInterfaceType,
InvokeInfo = invokeInfo
});
}
public Task InvokeAsync(Func <TServiceInterface, Task> method, InvokeInfo invokeInfo = null)
{
return(this.InvokeAsync(async provider =>
{
await method(provider).ConfigureAwait(false);
return Task.FromResult(true);
}, invokeInfo));
}
/// <summary>
/// This function is called when a proxy's method is called that should return void.
/// </summary>
/// <param name="method">Method implementing the service call using WCF</param>
/// <param name="invokeInfo"></param>
public void Invoke(Action <TServiceInterface> method, InvokeInfo invokeInfo = null)
{
Invoke(provider =>
{
method(provider);
return(new VoidReturnType());
}, invokeInfo);
}
private TServiceInterface Delay(
int iteration,
IDelayPolicy delayPolicy,
TServiceInterface provider,
InvokeInfo invokeInfo)
{
Thread.Sleep(delayPolicy.GetDelay(iteration));
return(RefreshProvider(provider, iteration, invokeInfo));
}
private void HandleOnBeforeInvoke(int retryCounter, InvokeInfo invokeInfo)
{
this.OnBeforeInvoke(this, new OnInvokeHandlerArguments
{
ServiceType = _originalServiceInterfaceType,
RetryCounter = retryCounter,
InvokeInfo = invokeInfo
});
}
private async Task <TServiceInterface> DelayAsync(
int iteration,
IDelayPolicy delayPolicy,
TServiceInterface provider,
InvokeInfo invokeInfo)
{
await Task.Delay(delayPolicy.GetDelay(iteration)).ConfigureAwait(false);
return(RefreshProvider(provider, iteration, invokeInfo));
}
private void HandleOnException(Exception exception, int retryCounter, InvokeInfo invokeInfo)
{
this.OnException(this, new OnExceptionHandlerArguments
{
Exception = exception,
ServiceType = _originalServiceInterfaceType,
RetryCounter = retryCounter,
InvokeInfo = invokeInfo,
});
}
private void HandleOnAfterInvoke(int retryCounter, object response, InvokeInfo invokeInfo)
{
// set return value if non-void
if (invokeInfo != null && response != null && response.GetType() != typeof(VoidReturnType))
{
invokeInfo.MethodHasReturnValue = true;
invokeInfo.ReturnValue = response;
}
this.OnAfterInvoke(this, new OnInvokeHandlerArguments
{
ServiceType = _originalServiceInterfaceType,
RetryCounter = retryCounter,
InvokeInfo = invokeInfo,
});
}
private void DisposeProvider(TServiceInterface provider, int retryCount, InvokeInfo invokeInfo)
{
var communicationObject = provider as ICommunicationObject;
if (communicationObject == null || communicationObject.State == CommunicationState.Closed)
{
return;
}
bool success = false;
try
{
if (communicationObject.State != CommunicationState.Faulted)
{
communicationObject.Close();
success = true;
}
}
catch (CommunicationException ex)
{
this.HandleOnException(ex, retryCount, invokeInfo);
}
catch (TimeoutException ex)
{
this.HandleOnException(ex, retryCount, invokeInfo);
}
catch (Exception ex)
{
this.HandleOnException(ex, retryCount, invokeInfo);
throw;
}
finally
{
if (!success)
{
this.AbortServiceChannel(communicationObject, retryCount, invokeInfo);
}
}
}
private void AbortServiceChannel(ICommunicationObject communicationObject, int retryCount, InvokeInfo invokeInfo)
{
try
{
communicationObject.Abort();
}
catch (Exception ex)
{
this.HandleOnException(ex, retryCount, invokeInfo);
}
}
/// <summary>
/// Refreshes the proxy by disposing and recreating it if it's faulted.
/// </summary>
/// <param name="provider">The provider.</param>
/// <param name="retryCount">Number of retries to perform</param>
/// <param name="invokeInfo"></param>
/// <returns></returns>
private TServiceInterface RefreshProvider(TServiceInterface provider, int retryCount, InvokeInfo invokeInfo)
{
var communicationObject = provider as ICommunicationObject;
if (communicationObject == null)
{
return(_wcfActionProviderCreator());
}
if (communicationObject.State == CommunicationState.Opened)
{
return(provider);
}
DisposeProvider(provider, retryCount, invokeInfo);
provider = null;
return(_wcfActionProviderCreator());
}
private void HandleOnCallSuccess(TimeSpan callDuration, object response, int requestAttempts, InvokeInfo invokeInfo)
{
if (invokeInfo != null && response != null && response.GetType() != typeof(VoidReturnType))
{
invokeInfo.MethodHasReturnValue = true;
invokeInfo.ReturnValue = response;
}
this.OnCallSuccess(this, new OnCallSuccessHandlerArguments
{
ServiceType = _originalServiceInterfaceType,
InvokeInfo = invokeInfo,
CallDuration = callDuration,
RequestAttempts = requestAttempts
});
}
public async Task <TResponse> InvokeAsync <TResponse>(Func <TServiceInterface, Task <TResponse> > method, InvokeInfo invokeInfo = null)
{
TServiceInterface provider = RefreshProvider(null, 0, invokeInfo);
TResponse lastResponse = default(TResponse);
IDelayPolicy delayPolicy = DelayPolicyFactory();
var sw = Stopwatch.StartNew();
try
{
this.HandleOnCallBegin(invokeInfo);
Exception mostRecentException = null;
for (int i = 0; i < RetryCount + 1; i++)
{
try
{
this.HandleOnBeforeInvoke(i, invokeInfo);
TResponse response = await method(provider).ConfigureAwait(false);
this.HandleOnAfterInvoke(i, response, invokeInfo);
if (ResponseInRetryable(response))
{
lastResponse = response;
provider = await DelayAsync(i, delayPolicy, provider, invokeInfo).ConfigureAwait(false);
continue;
}
sw.Stop();
response = this.ExecuteResponseHandlers(response);
this.HandleOnCallSuccess(sw.Elapsed, response, (i + 1), invokeInfo);
return(response);
}
catch (Exception ex)
{
this.HandleOnException(ex, i, invokeInfo);
// determine whether to retry the service call
if (ExceptionIsRetryable(ex))
{
mostRecentException = ex;
provider = await DelayAsync(i, delayPolicy, provider, invokeInfo).ConfigureAwait(false);
}
else
{
throw;
}
}
}
if (mostRecentException != null)
{
if (RetryCount == 0)
{
throw mostRecentException;
}
var exception = this.RetryFailureExceptionFactory(this.RetryCount, mostRecentException, invokeInfo);
throw exception;
}
}
finally
{
DisposeProvider(provider, -1, invokeInfo);
}
return(lastResponse);
}