<p>Of course those are lasers shooting from the rodent's eyes!!!</p>

      <p>This is just a do while loop with some call backs. Super simple and hopefully covers more retry scenarios than the libraries I checked out.</p>

      <p><strong><a href="https://github.com/TheDev6/Treadmill">Source Code on Github</a></strong></p>

      <script type="syntaxhighlighter" class="brush: csharp"><![CDATA[
namespace Treadmill
{
    using System;
    using System.Threading;
    using System.Threading.Tasks;

    public class Tread : ITread
    {
        public virtual T Try<T>(Func<T> func, int tryCount, Func<T, Exception, bool> until, int? intervalMilliseconds = null, Action<Exception> onException = null, Action<T, Exception> afterLastRun = null)
        {
            var result = default(T);
            Exception runningException;
            var runCount = 0;

            do
            {
                runningException = null;
                if (runCount > 0)
                {
                    if (intervalMilliseconds.HasValue)
                    {
                        Thread.Sleep(intervalMilliseconds.Value);
                    }
                }

                try
                {
                    runCount++;
                    result = func();
                }
                catch (Exception ex)
                {
                    runningException = ex;
                    onException?.Invoke(ex);
                }

            } while (!until(result, runningException) && runCount < tryCount);

            afterLastRun?.Invoke(result, runningException);

            return result;
        }

        public virtual void Try(Action action, int tryCount, Func<Exception, bool> until, int? intervalMilliseconds = null, Action<Exception> onException = null, Action<Exception> afterLastRun = null)
        {
            Exception runningException;
            var runCount = 0;

            do
            {
                runningException = null;
                if (runCount > 0)
                {
                    if (intervalMilliseconds.HasValue)
                    {
                        Thread.Sleep(intervalMilliseconds.Value);
                    }
                }

                try
                {
                    runCount++;
                    action();
                }
                catch (Exception ex)
                {
                    runningException = ex;
                    onException?.Invoke(ex);
                }

            } while (!until(runningException) && runCount < tryCount);

            afterLastRun?.Invoke(runningException);
        }

        public virtual async Task<T> TryAsync<T>(Func<Task<T>> func, int tryCount, Func<T, Exception, bool> until, int? intervalMilliseconds = null, Action<Exception> onException = null, Action<T, Exception> afterLastRun = null)
        {
            var result = default(T);
            Exception runningException;
            var runCount = 0;

            do
            {
                runningException = null;
                if (runCount > 0)
                {
                    if (intervalMilliseconds.HasValue)
                    {
                        Thread.Sleep(intervalMilliseconds.Value);
                    }
                }

                try
                {
                    runCount++;
                    result = await func().ConfigureAwait(false);
                }
                catch (Exception ex)
                {
                    runningException = ex;
                    onException?.Invoke(ex);
                }

            } while (!until(result, runningException) && runCount < tryCount);

            afterLastRun?.Invoke(result, runningException);

            return result;
        }

        public virtual async Task TryAsync(Func<Task> func, int tryCount, Func<Exception, bool> until, int? intervalMilliseconds = null, Action<Exception> onException = null, Action<Exception> afterLastRun = null)
        {
            Exception runningException;
            var runCount = 0;

            do
            {
                runningException = null;
                if (runCount > 0)
                {
                    if (intervalMilliseconds.HasValue)
                    {
                        Thread.Sleep(intervalMilliseconds.Value);
                    }
                }

                try
                {
                    runCount++;
                    await func().ConfigureAwait(false);
                }
                catch (Exception ex)
                {
                    runningException = ex;
                    onException?.Invoke(ex);
                }

            } while (!until(runningException) && runCount < tryCount);

            afterLastRun?.Invoke(runningException);
        }
    }
}

]]></script>

Tests which can serve as examples as well.

<script type="syntaxhighlighter" class="brush: csharp"><![CDATA[
namespace Treadmill.Tests
{
    using System;
    using System.Collections.Generic;
    using System.Threading.Tasks;
    using FluentAssertions;
    using NUnit.Framework;


    [TestFixture]
    public class TreadTests
    {
        private static readonly object[] TrySource =
        {
            new object[]
            {
                3,
                4
            },
            new object[]
            {
                1,
                2
            },
            new object[]
            {
                0,
                1
            },
        };

        [Test, TestCaseSource(nameof(TrySource))]
        public void Try_T(int exceptionsUntil, int tryCount)
        {
            var tread = new Tread();

            var runCount = 0;
            var myStr = "My Test String";
            Func<string> myFunc = () =>
            {
                runCount++;
                if (runCount <= exceptionsUntil)
                {
                    throw new Exception("boom");

                }
                return myStr;
            };



            var exceptionList = new List<Exception>();
            string lastStr = null;
            Exception lastException = null;

            var result = tread.Try(
                func: myFunc,
                tryCount: tryCount,
                until: (str, exception) => str != null && exception == null,
                intervalMilliseconds: 25,
                onException: exception => { exceptionList.Add(exception); },
                afterLastRun: (s, exception) =>
                {
                    lastStr = s;
                    lastException = exception;
                }
                );


            result.ShouldBeEquivalentTo(myStr);
            lastStr.ShouldBeEquivalentTo(myStr);
            lastException.ShouldBeEquivalentTo(null);
            exceptionList.Count.ShouldBeEquivalentTo(exceptionsUntil);
            runCount.ShouldBeEquivalentTo(tryCount);
        }

        [Test, TestCaseSource(nameof(TrySource))]
        public void Try(int exceptionsUntil, int tryCount)
        {
            var tread = new Tread();

            var runCount = 0;
            var myStr = "My Test String";
            Action myAction = () =>
            {
                runCount++;
                if (runCount <= exceptionsUntil)
                {
                    throw new Exception("boom");
                }
            };



            var exceptionList = new List<Exception>();
            Exception lastException = null;

            tread.Try(
                action: myAction,
                tryCount: 10,
                until: (exception) => exception == null,
                intervalMilliseconds: 25,
                onException: exception => { exceptionList.Add(exception); },
                afterLastRun: (exception) =>
                {
                    lastException = exception;
                }
                );

            lastException.ShouldBeEquivalentTo(null);
            exceptionList.Count.ShouldBeEquivalentTo(exceptionsUntil);
            runCount.ShouldBeEquivalentTo(tryCount);
        }


        [Test, TestCaseSource(nameof(TrySource))]
        public async Task Try_TaskT(int exceptionsUntil, int tryCount)
        {
            var tread = new Tread();

            var runCount = 0;
            var myStr = "My Test String";
            Func<Task<string>> myFunc = async () =>
            {
                runCount++;
                if (runCount <= exceptionsUntil)
                {
                    throw new Exception("boom");
                }
                return await Task.FromResult(myStr).ConfigureAwait(false);
            };

            var exceptionList = new List<Exception>();
            string lastStr = null;
            Exception lastException = null;

            var result = await tread.TryAsync(
                func: myFunc,
                tryCount: tryCount,
                until: (str, exception) => str != null && exception == null,
                intervalMilliseconds: 25,
                onException: exception => { exceptionList.Add(exception); },
                afterLastRun: (s, exception) =>
                {
                    lastStr = s;
                    lastException = exception;
                }
                ).ConfigureAwait(false);

            result.ShouldBeEquivalentTo(myStr);
            lastStr.ShouldBeEquivalentTo(myStr);
            lastException.ShouldBeEquivalentTo(null);
            exceptionList.Count.ShouldBeEquivalentTo(exceptionsUntil);
            runCount.ShouldBeEquivalentTo(tryCount);
        }

        [Test, TestCaseSource(nameof(TrySource))]
        public async Task Try_Task(int exceptionsUntil, int tryCount)
        {
            var tread = new Tread();

            var runCount = 0;
            Func<Task> myFunc = async () =>
            {
                runCount++;
                if (runCount <= exceptionsUntil)
                {
                    throw new Exception("boom");
                }
                await Task.Run(() => { }).ConfigureAwait(false);
            };

            var exceptionList = new List<Exception>();
            Exception lastException = null;

            await tread.TryAsync(
                func: myFunc,
                tryCount: 10,
                until: (exception) => exception == null,
                intervalMilliseconds: 25,
                onException: exception => { exceptionList.Add(exception); },
                afterLastRun: (exception) =>
                {
                    lastException = exception;
                }
                ).ConfigureAwait(false);

            lastException.ShouldBeEquivalentTo(null);
            exceptionList.Count.ShouldBeEquivalentTo(exceptionsUntil);
            runCount.ShouldBeEquivalentTo(tryCount);
        }
    }
}

]]></script>

Jetbrains DotCover results
<p><img class="img-thumbnail"  alt="Test Coverage" src="https://dev6.blob.core.windows.net/blog-images/treadmill-retry-tests.jpg" /></p>

A dead simple retry library with callbacks for your own retry behavior.

Allan Chadwick

Treadmill Retry