RetryPolicy Using Microsoft Practices Enterprise Library

/// <summary>
/// Provides the transient error detection logic that can recognize transient faults when dealing with reading online feed.
/// </summary>
internal class DownloadFeedTrasientErrorDetectionStrategy : ITransientErrorDetectionStrategy
{
    /// <summary>
    /// Determines whether the specified exception represents a transient failure that can be compensated by a retry.
    /// </summary>
    /// <param name="ex">The exception object to be verified.</param>
    /// <returns>True if the specified exception is considered as transient, otherwise false.</returns>
    public bool IsTransient(Exception ex)
    {
        return CheckIsTransientInternal(ex);
    }

    /// <summary>
    /// Allows you to override the call to change or extend the behavior by extending this class.
    /// </summary>
    /// <param name="ex">The error to check.</param>
    /// <returns></returns>
    protected virtual bool CheckIsTransientInternal(Exception ex)
    {
        return CheckIsTransient(ex);
    }

    private static bool CheckIsTransient(Exception ex)
    {
        if (ex is TimeoutException)
        {
            return true;
        }
        else if (ex is WebException)
        {
            return true;
        }
        else if (ex is UnauthorizedAccessException)
        {
            return false;
        }

        return false;
    }
}

view rawDownloadFeedTrasientErrorDetectionStrategy.cs hosted by GitHub

A straightforward usage of Retry utility.

public class FeedDao
{
    private readonly RetryPolicy retryPolicy;

    public FeedDao()
    {
        // setup retry policy that will try 3 times, with fast retry for first time and then
        // with incremental interval by 1.5 seconds.
        this.retryPolicy =
            new RetryPolicy<DownloadFeedTrasientErrorDetectionStrategy>(
                new Incremental(3, TimeSpan.FromSeconds(0), TimeSpan.FromSeconds(1.5))
                {
                    FastFirstRetry = true
                });

        // Set tracing if retry happened.
        this.retryPolicy.Retrying += (s, e) =>
            Trace.TraceWarning("An error occurred in attempt number {1} to download feed: {0}", e.LastException.Message, e.CurrentRetryCount);
    }

    public void GetFeed()
    {
        this.retryPolicy.ExecuteAction(() => this.DownloadFeed(feed_source));
    }

    private string DownloadFeed(string source)
    {
        // logic to retrieve feeds
        return result;
    }
}

view rawFeedDao.cs hosted by GitHub.

Code Explanation

The RetryPolicy is a class from the TransientFaultHandling namespace.

this.retryPolicy = new RetryPolicy<DownloadFeedTrasientErrorDetectionStrategy>(
    new Incremental(3, TimeSpan.FromSeconds(0), TimeSpan.FromSeconds(1.5))
{
    FastFirstRetry = true
});

The above snippet is an interesting one. Here we’ve used the Generic constructor of RetryPolicy. The class Incremental is RetryStrategy which takes similar arguments as defined in the RetryPolicy class constructor.

this.retryPolicy.ExecuteAction(() => this.DownloadFeed(feed_source));

The above line shows how the actual network-based method call is wrapped with Retry logic. It takes a simple void Action delegate which is represented as LambdaExpression.

This is the simplest usage of RetryPolicy. Really easy, isn’t it? But this is all you need to do to introduce Retry stuff in your application. Who else is using, Entity Framework, Windows Azure service, and many other important products are using this library.