using System;

using System.Diagnostics;

using System.Threading;

using System.Threading.Tasks;

​

using Polly;

using Polly.Retry;

public class Program

{

    public static async Task Main()

    {

        var pipeline = new ResiliencePipelineBuilder()

            .AddFancyRetry(new () {

                ShouldHandle = args => PredicateResult.True(),

                MaxRetryAttempts = 3,

                Delay = TimeSpan.FromSeconds(1),

            })

            .Build();

        await pipeline.ExecuteAsync(async ct => { await Task.Delay(100); }, CancellationToken.None);

    }

}

​

​

public sealed class RetryReporterStrategy: ResilienceStrategy

{

    private readonly ResiliencePropertyKey<int> _attemptCount;

    public RetryReporterStrategy(ResiliencePropertyKey<int> attemptCount)

    {

        _attemptCount = attemptCount;

    }

​

    protected override async ValueTask<Outcome<TResult>> ExecuteCore<TResult, TState>(

        Func<ResilienceContext, TState, ValueTask<Outcome<TResult>>> callback,

        ResilienceContext context,

        TState state)

    {

        Stopwatch watch = Stopwatch.StartNew();

        var result = await callback(context, state).ConfigureAwait(context.ContinueOnCapturedContext);

        watch.Stop();

​

        context.Properties.TryGetValue(_attemptCount, out var attempts);

        if (result.Exception is not null)

            Console.WriteLine($"The operation failed after {attempts+1} tries, in {watch.Elapsed.TotalSeconds} seconds");

        else

            Console.WriteLine($"The operation successeded after {attempts+1} tries, in {watch.Elapsed.TotalSeconds} seconds");

​

        return result;

    }

}

​

public static class RetryExtensions

{ 

    public static ResiliencePipelineBuilder AddFancyRetry(this ResiliencePipelineBuilder builder, RetryStrategyOptions options)

    {

        ResiliencePropertyKey<int> attemptCountKey = new(nameof(attemptCountKey));

        return builder

        .AddStrategy(context => new RetryReporterStrategy(attemptCountKey), options)

        .AddRetry(new() {

            BackoffType = options.BackoffType,

            Delay = options.Delay,

            DelayGenerator = options.DelayGenerator,

            MaxDelay = options.MaxDelay,

            MaxRetryAttempts = options.MaxRetryAttempts,

            Name = options.Name,

            Randomizer = options.Randomizer,

            OnRetry = args =>

            {

                args.Context.Properties.Set(attemptCountKey, args.AttemptNumber);

                return options.OnRetry?.Invoke(args) ?? default;

            },

            ShouldHandle = options.ShouldHandle,

            UseJitter = options.UseJitter

        });

    }

}