Why is the exception not being handled in this asynchronous rewrapper using TPL?

What you want to do is not easy. In fact, it is so hard to get "right" that I wrote a library specifically to address this problem ( Rackspace Thread Library , Apache 2.0).

Desired behavior

The desired behavior for your code is most easily described with async

/ await

, although the final version of the code will not use this feature. I made a few changes to your method Retry

for this.

• To improve the method's ability to support truly asynchronous operations, I changed the parameter work
  
  from Func<T>
  
  to Func<Task<T>>
  
  .
• To avoid blocking the thread unnecessarily (even if it's a background thread), I used Task.Delay
  
  instead Thread.Sleep
  
  .
• I made the assumption that onException
  
  never null
  
  . While this assumption is not easy to overlook for code using async
  
  / await
  
  , it could be resolved for the implementation below if needed.
• I made the assumption that if the task being returned work
  
  enters a state Faulted
  
  , it will have a property InnerExceptions
  
  that only contains 1 exception. If it contains more than one exception, all but the first will be ignored. While this assumption is not easy to overlook for code using async
  
  / await
  
  , it could be resolved for the implementation below if needed.

Here is the resulting implementation. Note that I could have used a loop for

instead of a loop while

, but as you will see, this complicates the next step.

public async Task<T> Retry<T, TException>(Func<Task<T>> work, Action<TException> onException, TimeSpan retryInterval, int maxExecutionCount)
    where TException : Exception
{
    int count = 0;
    while (count < maxExecutionCount)
    {
        if (count > 0)
            await Task.Delay(retryInterval);

        count++;

        try
        {
            return await work();
        }
        catch (TException ex)
        {
            onException(ex);
        }
        catch (Exception ex)
        {
            throw new RetryWrapperException("Unexpected exception occurred", ex);
        }
    }

    string message = string.Format("Retry unsuccessful after: {0} attempt(s)", maxExecutionCount);
    throw new RetryWrapperException(message);
}

      

        
        
        
      

    

Porting to .NET 4.0

Converting this code to .NET 4.0 (and even .NET 3.5) uses the following features of the Rackspace threading library:

• TaskBlocks.While
  
  : To convert the loop while
  
  .
• CoreTaskExtensions.Select
  
  : to perform synchronous operations after successfully completing an antecedent task.
• CoreTaskExtensions.Then
  
  : to perform asynchronous operations after the antecedent task has successfully completed.
• CoreTaskExtensions.Catch
  
  (new for V1.1): for exception handling.
• DelayedTask.Delay
  
  (new for V1.1): for behavior Task.Delay
  
  .

There are several behavioral differences between this implementation and above. In particular:

• If it work
  
  does null
  
  , the one returned by this method Task
  
  will transition into a canceled state (as shown by this test ), where the above method will go into an error state due to a NullReferenceException
  
  .
• This implementation behaves as if it was ConfigureAwait(false)
  
  called before each await
  
  in the previous implementation. At least in my opinion, it's actually not bad.

• If a method onException
  
  throws an exception, this implementation will wrap that exception in RetryWrapperException
  
  . In other words, this implementation actually models this code, not the block written in the Desired Behavior section :

  try
  {
      try
      {
          return await work();
      }
      catch (TException ex)
      {
          onException(ex);
      }
  }
  catch (Exception ex)
  {
      throw new RetryWrapperException("Unexpected exception occurred", ex);
  }
  
        
  
          
          
          
        
  
      

Here is the resulting implementation:

public static Task<T> Retry<T, TException>(Func<Task<T>> work, Action<TException> onException, TimeSpan retryInterval, int maxExecutionCount)
    where TException : Exception
{
    int count = 0;
    bool haveResult = false;
    T result = default(T);

    Func<bool> condition = () => count < maxExecutionCount;
    Func<Task> body =
        () =>
        {
            Task t1 = count > 0 ? DelayedTask.Delay(retryInterval) : CompletedTask.Default;

            Task t2 =
                t1.Then(
                    _ =>
                    {
                        count++;
                        return work();
                    })
                .Select(
                    task =>
                    {
                        result = task.Result;
                        haveResult = true;
                    });

            Task t3 =
                t2.Catch<TException>(
                    (_, ex) =>
                    {
                        onException(ex);
                    })
                .Catch<Exception>((_, ex) =>
                    {
                        throw new RetryWrapperException("Unexpected exception occurred", ex);
                    });

            return t3;
        };

    Func<Task, T> selector =
        _ =>
        {
            if (haveResult)
                return result;

            string message = string.Format("Retry unsuccessful after: {0} attempt(s)", maxExecutionCount);
            throw new RetryWrapperException(message);
        };

    return
        TaskBlocks.While(condition, body)
        .Select(selector);
}

      

        
        
        
      

    

Test example

The following test method demonstrates the features described above as described.

[TestMethod]
public void Run()
{
    Func<Task<string>> work = GetSampleResultAsync;
    Action<InvalidOperationException> onException = e => Console.WriteLine("Caught the exception: {0}", e);
    TimeSpan retryInterval = TimeSpan.FromSeconds(5);
    int maxRetryCount = 4;

    Task<string> resultTask = Retry(work, onException, retryInterval, maxRetryCount);
    Console.WriteLine("This wrapper doesn't block");

    var result = resultTask.Result;
    Assert.IsFalse(string.IsNullOrWhiteSpace(result));
    Assert.AreEqual("Sample result!", result);
}

private static int _counter;

private static Task<string> GetSampleResultAsync()
{
    if (_counter < 3)
    {
        _counter++;
        throw new InvalidOperationException("Baaah!");
    }

    return CompletedTask.FromResult("Sample result!");
}

      

        
        
        
      

    

Future considerations

If you really want to implement rock hardness, I recommend that you further modify your code in the following ways.

• Cancellation of support.

  • Add a parameter CancellationToken cancellationToken
    
    as the last parameter of the method Retry
    
    .
  • Change the type work
    
    to Func<CancellationToken, Task<T>>
    
    .
  • Pass the argument cancellationToken
    
    to work
    
    and to the call DelayedTask.Delay
    
    .

• Support deferral policies. You can remove the options retryInterval
  
  and maxExecutionCount
  
  and use instead IEnumerable<TimeSpan>
  
  , or you can enable and use the interface, for example IBackoffPolicy
  
  along with the default implementation, for example BackoffPolicy
  
  (both licensed by MIT).