timeout usando o Polly

[marcialwushu]

using System;
using System.Net.Http;
using Polly;
using Polly.Timeout;

public class TimeoutExample
{
    public void Run()
    {
        var timeoutPolicy = Policy.Timeout(TimeSpan.FromSeconds(5));

        try
        {
            timeoutPolicy.Execute(() => DoSomething());
        }
        catch (TimeoutException ex)
        {
            Console.WriteLine("Operation timed out: " + ex.Message);
        }
        catch (HttpRequestException ex)
        {
            Console.WriteLine("Failed: " + ex.Message);
        }
    }

    private void DoSomething()
    {
        var client = new HttpClient();
        var response = client.GetAsync("https://www.example.com").Result;

        // Throw exception if response is unsuccessful
        response.EnsureSuccessStatusCode();
    }
}

[marcialwushu]

Neste exemplo, estamos usando a política de timeout do Polly para definir um limite de tempo máximo de 5 segundos para a operação. Usamos o método Execute da política de timeout para executar a função que faz a chamada para o método DoSomething().

Se a operação não for concluída dentro do limite de tempo especificado, a exceção TimeoutException será lançada e capturada no bloco catch. Caso contrário, se ocorrer uma exceção do tipo HttpRequestException, ela será capturada no segundo bloco catch.

Observe que a política de timeout é aplicada independentemente da política de retry, que pode ser usada em conjunto com a política de timeout para tentar executar a operação novamente se ocorrer uma exceção devido a uma falha na rede ou em outro lugar.

[marcialwushu]

utilizando a política de timeout do Polly com a estratégia pessimista (TimeoutStrategy.Pessimistic).

using System;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using Polly;
using Polly.Timeout;

public class TimeoutExample
{
    public async Task Run()
    {
        var timeoutPolicy = Policy.TimeoutAsync(TimeSpan.FromSeconds(5), TimeoutStrategy.Pessimistic);

        try
        {
            await timeoutPolicy.ExecuteAsync(ct => DoSomething(ct), CancellationToken.None);
        }
        catch (TimeoutRejectedException ex)
        {
            Console.WriteLine("Operation timed out: " + ex.Message);
        }
        catch (HttpRequestException ex)
        {
            Console.WriteLine("Failed: " + ex.Message);
        }
    }

    private async Task DoSomething(CancellationToken cancellationToken)
    {
        var cts = new CancellationTokenSource();
        cts.CancelAfter(TimeSpan.FromSeconds(5));  // Definir tempo máximo de timeout

        using (var client = new HttpClient())
        {
            var response = await client.GetAsync("https://www.example.com", cts.Token);

            // Verificar se a requisição foi concluída antes do timeout
            if (!response.IsSuccessStatusCode)
            {
                cancellationToken.ThrowIfCancellationRequested(); // Verificar se o cancelamento foi solicitado
                response.EnsureSuccessStatusCode();
            }

            // Processar a resposta normalmente
            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine("Response: " + content);
        }
    }
}