How to implement re-try n times in case of exception in C#?

Question

I am developing a WPF 4.0 application in which we get the data from a remote web service. The web service exposes around 120+ methods to its clients. If a web service call from my WPF application fails, I need to retry it n times which is configurable via App.Config. How to implement this? Are there any design patterns that address this problem?

Answer 1

static T TryNTimes<T>(Func<T> func, int times)
{
  while (times>0)
  {
     try
     {
        return func();
     }
     catch(Exception e)
     {
       if (--times <= 0)
          throw;
     }

  }
}

Answer 2

I wrote this code not too long ago to do something similar to what you want. It can be modified to fit your needs. It's a generic wait method. Pass in a function and if the expected result is not returned, wait then retry and exit after X number of tries.

/// <summary>
    /// Wait for the result of func to return the expeceted result
    /// </summary>
    /// <param name="func">Function to execute each cycle</param>
    /// <param name="result">Desired result returned by func</param>
    /// <param name="waitInterval">How long to wait (ms) per cycle </param>
    /// <param name="cycles">How many times to execute func before failing</param>
    /// <returns>True if desired result was attained. False if specified time runs out before desired result is returned by func</returns>
    protected static bool WaitForEvent(Func<bool> func, bool result, int waitInterval, int cycles)
    {
        int waitCount = 0;
        while (func() != result)
        {
            if (waitCount++ < cycles)
            {
                Thread.Sleep(waitInterval);
            }
            else
            {
                return false;
            }
        }

        return true;

    }

Answer 3

while(retries < maxTries)
   try
   {
      //retryable code here
      break;
   }
   catch(Exception ex)
   {
      if(++retries == maxTries)
         throw;
      continue;
   }

Certainly nothing fancy but it'll get the job done. The main pattern, which would be common to pretty much any implementation, is some looping construct containing and somewhat controlled by a try-catch; that can either be a recursive call or some iterative loop such as the while loop above. Make sure you exit the loop properly after a successful attempt, and keep track of retries; failure to do either will cause an infinite loop.

Answer 4

You can use a functional approach to this:

class Program
{
    static T Retry<T, TException>(Func<T> thingToTry, int timesToRetry)
        where TException : Exception
    {
        // Start at 1 instead of 0 to allow for final attempt
        for (int i = 1; i < timesToRetry; i++)
        {
            try
            {
                return thingToTry();
            }
            catch (TException)
            {
                // Maybe: Trace.WriteLine("Failed attempt...");
            }
        }

        return thingToTry(); // Final attempt, let exception bubble up
    }

    static int ServiceCall()
    {
        if (DateTime.Now.Ticks % 2 == 0)
        {
            throw new InvalidOperationException("Randomly not working");
        }

        return DateTime.Now.Second;
    }

    static void Main()
    {
        int s = Retry<int, InvalidOperationException>(ServiceCall, 10);
    }
}

You can use this to catch specific exceptions (add more TException generic parameters if necessary).

Answer 5

while(true)
{

try
{
 Method();
 break;
}
catch(Exception ex)
{
 i++;
 if(i == n) throw ex;
}

}

Answer 6

Here is a similar code that wraps IO sharing violation. It's the same idea: we have a delegate and a wrapper static method:

/// <summary>
/// Defines a sharing violation wrapper delegate.
/// </summary>
public delegate void WrapSharingViolationsCallback();

/// <summary>
/// Wraps sharing violations that could occur on a file IO operation.
/// </summary>
/// <param name="action">The action to execute. May not be null.</param>
/// <param name="exceptionsCallback">The exceptions callback. May be null.</param>
/// <param name="retryCount">The retry count.</param>
/// <param name="waitTime">The wait time in milliseconds.</param>
public static void WrapSharingViolations(WrapSharingViolationsCallback action, WrapSharingViolationsExceptionsCallback exceptionsCallback, int retryCount, int waitTime)
{
    if (action == null)
        throw new ArgumentNullException("action");

    for (int i = 0; i < retryCount; i++)
    {
        try
        {
            action();
            return;
        }
        catch (IOException ioe)
        {
            if ((IsSharingViolation(ioe)) && (i < (retryCount - 1)))
            {
                bool wait = true;
                if (exceptionsCallback != null)
                {
                    wait = exceptionsCallback(ioe, i, retryCount, waitTime);
                }
                if (wait)
                {
                    Thread.Sleep(waitTime);
                }
            }
            else
            {
                throw;
            }
        }
    }
}

And then, we call it this way (lambda expression suits perfectly here):

    WrapSharingViolations(() => DoWhatever(...));

Answer 7

You might be able to do this with a GOTO (gasp)

int count = 0;

TryAgain:
try 
{
   // Do something with your web service
}  
catch(Exception e) 
{
    if(count < numberOfAttemptsAllowed)
    {
         count++;
         goto TryAgain;
    } 
}

I'm sure there might be a better way, but this might do what you need.