using System;

using System.Threading;

using System.Threading.Tasks;

​

using Polly;

using Polly.Timeout;

public class Program

{

    public static async Task Main()

    {

        //Sync Policy with Pessimistic

        /*

        var syncTimeoutPessimistic = Policy.Timeout(

            TimeSpan.FromSeconds(3), 

            TimeoutStrategy.Pessimistic, 

            (_, __, ___) =>

        {

            "onTimeout is fired".Dump();

        });

​

        try

        {

            syncTimeoutPessimistic.Execute(() =>

            {

                Thread.Sleep(5_000);

                "Decorated operation is finished".Dump();

            });

        } 

        catch(TimeoutRejectedException)

        {

            "Timeout has kicked in".Dump();

        }

        */

​

        //Sync Policy with Optimistic

        /*

        var syncTimeoutOptimistic = Policy.Timeout(

            TimeSpan.FromSeconds(3), 

            TimeoutStrategy.Optimistic, 

            (_, __, ___) =>

        {

            "onTimeout is fired".Dump();

        });

​

        try

        {

            syncTimeoutOptimistic.Execute((ct) =>

            {

                var result = Task.Run(() => { Thread.Sleep(5_000); return Task.CompletedTask; });

                result.Wait(ct);

                "Decorated operation is finished".Dump();

            }, CancellationToken.None);

        } 

        catch(TimeoutRejectedException)

        {

            "Timeout has kicked in".Dump();

        }

        */

        //Async Policy with Pessimistic

        /*

        var asyncTimeoutPessimistic = Policy.TimeoutAsync(

            TimeSpan.FromSeconds(3), 

            TimeoutStrategy.Pessimistic, 

            (_, __, ___) =>

        {

            "onTimeout is fired".Dump();

            return Task.CompletedTask;

        });

​

        try

        {

            await asyncTimeoutPessimistic.ExecuteAsync(async () =>

            {

                await Task.Delay(5_000);

                "Decorated operation is finished".Dump();

            });

        } 

        catch(TimeoutRejectedException)

        {

            "Timeout has kicked in".Dump();

        }

        */

        //Async Policy with Pessimistic

        var asyncTimeoutOptimistic = Policy.TimeoutAsync(

            TimeSpan.FromSeconds(3), 

            TimeoutStrategy.Optimistic, 

            (_, __, ___) =>

        {

            "onTimeout is fired".Dump();

            return Task.CompletedTask;

        });

​

        try

        {

            await asyncTimeoutOptimistic.ExecuteAsync(async (ct) =>

            {

                await Task.Delay(5_000, ct);

                "Decorated operation is finished".Dump();

            }, CancellationToken.None);

        } 

        catch(TimeoutRejectedException)

        {

            "Timeout has kicked in".Dump();

        }

    }

}