using System;

using System.Threading;

using System.Threading.Tasks;

​

namespace vtex.myapp

{

    /// <summary>

    /// When working with cloud services and Docker containers, it's very important to always catch

    /// TimeoutException, and retry the operation.  

    /// RetryWithExponentialBackoff makes it easy to implement such pattern. 

    /// Usage:

    ///     var retry = new RetryWithExponentialBackoff();

    ///     await retry.RunAsync(async ()=>

    ///     {

    ///        // work with HttpClient

    ///     });

    /// </summary>

    public sealed class RetryWithExponentialBackoff

    {

        private readonly int maxBackoffMs, initialWaitTimeMs, minJitterMs, maxJitterMs;

        public RetryWithExponentialBackoff(int maxBackoffMs = 64000, int initialWaitTimeMs = 200, int minJitterMs = 100, int maxJitterMs = 1000)

        {

            this.maxBackoffMs = maxBackoffMs;

            this.initialWaitTimeMs = initialWaitTimeMs;

            this.minJitterMs = minJitterMs;

            this.maxJitterMs = maxJitterMs;

        }

​

        public async Task RunAsync(Func<CancellationToken, Task> func, Func<Exception, bool> validator, CancellationToken ct)

        {

            var backoff = new ExponentialBackoff(this.maxBackoffMs, this.initialWaitTimeMs, this.minJitterMs, this.maxJitterMs);

            var spent = false;

            while (!(spent = backoff.IsSpent))

            {

                ct.ThrowIfCancellationRequested();

                try

                {

                    await func(ct);

                    break;

                }

                catch (Exception ex)

                {

                    if (!validator(ex)) {

                        throw ex;   

                    }

                }

​

                await backoff.Delay(ct);

            }

            if (spent) {

                throw new Exception("Backoff spent");

            }

        }

    }

​

    struct ExponentialBackoff

    {

        private readonly int m_maxBackoffMs, m_initialWaitTimeMs, m_minJitterMs, m_maxJitterMs;

        private int m_currentWaitTime;

        private Random rnd;

        public ExponentialBackoff(int maxBackoffMs = 64000, int initialWaitTimeMs = 200, int minJitterMs = 100, int maxJitterMs = 1000)

        {

            m_maxBackoffMs = maxBackoffMs;

            m_initialWaitTimeMs = initialWaitTimeMs;

            m_minJitterMs = minJitterMs;

            m_maxJitterMs = maxJitterMs;

            m_currentWaitTime = initialWaitTimeMs / 2;

            rnd = new Random();

        }

​

        public Task Delay(CancellationToken ct)

        {

            var waitTime = m_currentWaitTime * 2;

            var jitter = rnd.Next(m_minJitterMs, m_maxJitterMs + 1);

            m_currentWaitTime = waitTime;

            return Task.Delay(waitTime + jitter, ct);

        }

​

        public bool IsSpent {

            get {

                return m_currentWaitTime >= m_maxBackoffMs;

            }

        }

    }

​

    public class Program

    {

        private static int i = 1;

        public static string SimulateNetworkFail()

        {

            if (i == 4)

            {

                Console.WriteLine("SUCCESS!");

                return "success";

            }

​

            Console.WriteLine("Retrying...");

            i += 1;

            throw new Exception("ex");

        }

​

        public static void Main()

        {

            Console.WriteLine("Running test...");

            var retry = new RetryWithExponentialBackoff(1000, 200, 100, 1000);

            var task = retry.RunAsync(async (_) =>

            {

                // Likely an async call - Here's the code you'll run multiple times

                SimulateNetworkFail();

            }, (Exception error) => {

                // Here you validate the exception your method got 

                // to ensure it's throttling or timeout

                return true;    

            }, CancellationToken.None);

            task.Wait();

        }

    }

}