using System;

using System.Reflection;

using System.Threading.RateLimiting;

using System.Threading.Tasks;

using Polly;

using Polly.RateLimiting;

using Polly.Testing;

using Polly.Registry;

public class Program

{

    public static async Task Main()

    {

        var registry = new ResiliencePipelineRegistry<string>();

        registry.TryAddBuilder("A", (builder, _) =>

        {

            builder.AddRateLimiter(new SlidingWindowRateLimiter(

                new SlidingWindowRateLimiterOptions

                {

                    PermitLimit = 10,

                    Window = TimeSpan.FromMinutes(1),

                    SegmentsPerWindow = 1

                }));

        });

        var pipeline = registry.GetPipeline("A");

        registry.Dispose();

        try

        {

            pipeline.Execute(() => {});

        }

        catch(ObjectDisposedException)

        {

            Console.WriteLine("Pipeline has been disposed");

        }

        var strategy = pipeline.GetPipelineDescriptor().FirstStrategy.StrategyInstance;

        var executeCore = typeof(ResilienceStrategy).GetMethod("ExecuteCore", BindingFlags.Instance | BindingFlags.NonPublic);

        executeCore = executeCore.MakeGenericMethod(new[] {typeof(object), typeof(object)});

​

        var context = ResilienceContextPool.Shared.Get();

        Func<ResilienceContext, object, ValueTask<Outcome<object>>> callback = (_, __) => Outcome.FromResultAsValueTask<object>("Test");

        var executeTask = (ValueTask<Outcome<object>>)executeCore.Invoke(strategy, parameters: [callback, context, null]);

        var executeOutcome = await executeTask;

        ResilienceContextPool.Shared.Return(context);

        Console.WriteLine(executeOutcome.Result);

    }

}