Retry Pattern




Basic counter with retry, throw error if it is not transient (Long-lasting) or retry attempts have not been reached


Retry logic on short term (remote) service exceptions





This example illustrates an implementation of the Retry pattern. The OperationWithBasicRetryAsync method, shown below, invokes an external service asynchronously through the TransientOperationAsync method (the details of this method will be specific to the service and are omitted from the sample code).




private int retryCount = 3;

public async Task OperationWithBasicRetryAsync()
  int currentRetry = 0;

  for (; ;)
      // Calling external service.
      await TransientOperationAsync();
      // Return or break.
    catch (Exception ex)
      Trace.TraceError("Operation Exception");


      // Check if the exception thrown was a transient exception
      // based on the logic in the error detection strategy.
      // Determine whether to retry the operation, as well as how 
      // long to wait, based on the retry strategy.
      if (currentRetry > this.retryCount || !IsTransient(ex))
        // If this is not a transient error 
        // or we should not retry re-throw the exception. 

    // Wait to retry the operation.
    // Consider calculating an exponential delay here and 
    // using a strategy best suited for the operation and fault.

// Async method that wraps a call to a remote service (details not shown).
private async Task TransientOperationAsync()

The statement that invokes this method is encapsulated within a try/catch block wrapped in a for loop. The for loop exits if the call to theTransientOperationAsync method succeeds without throwing an exception.


If the TransientOperationAsync method fails, the catch block examines the reason for the failure, and if it is deemed to be a transient error the code waits for a short delay before retrying the operation.


The for loop also tracks the number of times that the operation has been attempted, and if the code fails three times the exception is assumed to be more long lasting. If the exception is not transient or it is longlasting, the catch handler throws an exception. This exception exits the for loop and should be caught by the code that invokes the OperationWithBasicRetryAsync method.


The IsTransient method, shown below, checks for a specific set of exceptions that are relevant to the environment in which the code is run. The definition of a transient exception may vary according to the resources being accessed and the environment in which the operation is being performed.


private bool IsTransient(Exception ex)
  // Determine if the exception is transient.
  // In some cases this may be as simple as checking the exception type, in other 
  // cases it may be necessary to inspect other properties of the exception.
  if (ex is OperationTransientException)
    return true;

  var webException = ex as WebException;
  if (webException != null)
    // If the web exception contains one of the following status values 
    // it may be transient.
    return new[] {WebExceptionStatus.ConnectionClosed, 
                  WebExceptionStatus.RequestCanceled }.

  // Additional exception checking logic goes here.
  return false;