Polly Retry (Cómo Funciona para Desarrolladores)

Instalación de Polly

Puedes instalar Polly a través de la consola de administrador de paquetes NuGet usando el siguiente comando:

Install-Package Polly

O a través de .NET CLI:

dotnet add package Polly

Añadir declaraciones de uso de Polly

En tu archivo C#, incluye el espacio de nombres Polly:

using Polly;

using Polly;

Retroceso exponencial

El retroceso exponencial es una estrategia de reintento popular donde el retraso entre solicitudes y reintentos aumenta exponencialmente. Polly proporciona una manera conveniente de implementar retroceso exponencial usando WaitAndRetry().

var retryPolicy = Policy
    .Handle<HttpRequestException>()
    .WaitAndRetry(
        retryCount: 3, // Max retry attempts
        sleepDurationProvider: attempt => TimeSpan.FromSeconds(Math.Pow(2, attempt)), // Exponential delay
        onRetry: (exception, timeSpan, retryCount, context) =>
        {
            Console.WriteLine($"Retry {retryCount} due to {exception.Message}");
        });

var retryPolicy = Policy
    .Handle<HttpRequestException>()
    .WaitAndRetry(
        retryCount: 3, // Max retry attempts
        sleepDurationProvider: attempt => TimeSpan.FromSeconds(Math.Pow(2, attempt)), // Exponential delay
        onRetry: (exception, timeSpan, retryCount, context) =>
        {
            Console.WriteLine($"Retry {retryCount} due to {exception.Message}");
        });

Retry con Circuit Breaker

Combinar reintento con un interruptor de circuito puede mejorar aún más la resiliencia al prevenir reintentos repetidos cuando un servicio está fallando constantemente. Polly te permite combinar políticas de reintento e interruptor de circuito fácilmente.

// Define a circuit breaker policy
var circuitBreakerPolicy = Policy
    .Handle<HttpRequestException>()
    .CircuitBreaker(
        exceptionsAllowedBeforeBreaking: 3, // Number of exceptions before breaking
        durationOfBreak: TimeSpan.FromSeconds(30), // Time circuit stays open
        onBreak: (ex, breakDelay) =>
        {
            Console.WriteLine($"Circuit broken due to {ex.Message}. Retry after {breakDelay.TotalSeconds} seconds.");
        },
        onReset: () =>
        {
            Console.WriteLine("Circuit reset.");
        });

// Define a retry policy
var retryPolicy = Policy
    .Handle<HttpRequestException>()
    .WaitAndRetry(
        retryCount: 3, // Max retry attempts
        sleepDurationProvider: attempt => TimeSpan.FromSeconds(2), // Fixed retry delay
        onRetry: (exception, timeSpan, retryCount, context) =>
        {
            Console.WriteLine($"Retry {retryCount} due to {exception.Message}");
        });

// Combine both policies into a single policy wrap
var policyWrap = Policy.Wrap(circuitBreakerPolicy, retryPolicy);

// Define a circuit breaker policy
var circuitBreakerPolicy = Policy
    .Handle<HttpRequestException>()
    .CircuitBreaker(
        exceptionsAllowedBeforeBreaking: 3, // Number of exceptions before breaking
        durationOfBreak: TimeSpan.FromSeconds(30), // Time circuit stays open
        onBreak: (ex, breakDelay) =>
        {
            Console.WriteLine($"Circuit broken due to {ex.Message}. Retry after {breakDelay.TotalSeconds} seconds.");
        },
        onReset: () =>
        {
            Console.WriteLine("Circuit reset.");
        });

// Define a retry policy
var retryPolicy = Policy
    .Handle<HttpRequestException>()
    .WaitAndRetry(
        retryCount: 3, // Max retry attempts
        sleepDurationProvider: attempt => TimeSpan.FromSeconds(2), // Fixed retry delay
        onRetry: (exception, timeSpan, retryCount, context) =>
        {
            Console.WriteLine($"Retry {retryCount} due to {exception.Message}");
        });

// Combine both policies into a single policy wrap
var policyWrap = Policy.Wrap(circuitBreakerPolicy, retryPolicy);

En este ejemplo:

• CircuitBreaker() define una política de interruptor de circuito que se rompe después de 3 excepciones y permanece abierto durante 30 segundos.
• Policy.Wrap() combina las políticas de interruptor de circuito y reintento en una sola política.

Polly Retry con IronPDF

Al trabajar con IronPDF, podría haber escenarios donde necesites obtener datos de fuentes externas o realizar operaciones complejas antes de generar un PDF.

En tales casos, podrías encontrar fallas transitorias o problemas temporales que podrían llevar al fallo en la generación de PDFs. Para manejar estas fallas transitorias de manera elegante, puedes usar Polly Retry en conjunto con IronPDF.

Instalación de IronPDF y Polly

Antes de comenzar, asegúrate de instalar el paquete NuGet de IronPDF en tu proyecto.

Install-Package IronPdf

Uso de Polly Retry con IronPDF

Veamos un ejemplo donde usamos Polly Retry para manejar fallas transitorias al generar un PDF usando IronPDF. En el siguiente ejemplo, simularemos la obtención de datos de una API externa y luego generaremos un PDF basado en esos datos. Usaremos Polly Retry para ejecutar la operación de obtención de datos en caso de fallos.

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

namespace IronPdfWithPollyRetry
{
    public class Program
    {
        public static async Task Main(string[] args)
        {
            // Define a retry policy with async capability
            var retryPolicy = Policy
                .Handle<HttpRequestException>() // Specify exception type to handle
                .WaitAndRetryAsync(
                    3, // Retry attempts
                    retryAttempt => TimeSpan.FromSeconds(2), // Calculated retry delay
                    (exception, timeSpan, retryCount, context) =>
                    {
                        Console.WriteLine("Retry " + retryCount + " due to " + exception.Message);
                    });

            // Execute the retry policy asynchronously
            var pdf = await retryPolicy.ExecuteAsync(async () =>
            {
                var data = await FetchDataFromExternalApiAsync(); // Fetch data from an external source
                return GeneratePdfFromData(data); // Generate PDF using fetched data
            });

            pdf.SaveAs("GeneratedDocument.pdf");
        }

        // Simulate fetching data from an external API
        static async Task<string> FetchDataFromExternalApiAsync()
        {
            await Task.Delay(100); // Simulate delay
            throw new HttpRequestException("Failed to fetch data from external API");
        }

        // Generate PDF using IronPDF based on the fetched data
        static PdfDocument GeneratePdfFromData(string data)
        {
            var htmlContent = "<html><body><h1>Data: " + data + "</h1></body></html>";
            var renderer = new ChromePdfRenderer();
            return renderer.RenderHtmlAsPdf(htmlContent);
        }
    }
}

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

namespace IronPdfWithPollyRetry
{
    public class Program
    {
        public static async Task Main(string[] args)
        {
            // Define a retry policy with async capability
            var retryPolicy = Policy
                .Handle<HttpRequestException>() // Specify exception type to handle
                .WaitAndRetryAsync(
                    3, // Retry attempts
                    retryAttempt => TimeSpan.FromSeconds(2), // Calculated retry delay
                    (exception, timeSpan, retryCount, context) =>
                    {
                        Console.WriteLine("Retry " + retryCount + " due to " + exception.Message);
                    });

            // Execute the retry policy asynchronously
            var pdf = await retryPolicy.ExecuteAsync(async () =>
            {
                var data = await FetchDataFromExternalApiAsync(); // Fetch data from an external source
                return GeneratePdfFromData(data); // Generate PDF using fetched data
            });

            pdf.SaveAs("GeneratedDocument.pdf");
        }

        // Simulate fetching data from an external API
        static async Task<string> FetchDataFromExternalApiAsync()
        {
            await Task.Delay(100); // Simulate delay
            throw new HttpRequestException("Failed to fetch data from external API");
        }

        // Generate PDF using IronPDF based on the fetched data
        static PdfDocument GeneratePdfFromData(string data)
        {
            var htmlContent = "<html><body><h1>Data: " + data + "</h1></body></html>";
            var renderer = new ChromePdfRenderer();
            return renderer.RenderHtmlAsPdf(htmlContent);
        }
    }
}

Este código C# demuestra cómo usar la biblioteca Polly para implementar políticas de reintento con IronPDF para generar un documento PDF. El método Main inicializa una política de reintento usando el método WaitAndRetryAsync de Polly.

Esta política especifica que debe manejar HttpRequestException y reintentar la operación hasta 3 veces con un retraso de 2 segundos entre el intento inicial y los reintentos. Si ocurre un fallo de reintento, se imprime un mensaje en la consola indicando el número de intento de reintento y el mensaje de la excepción.

Dentro del método Main, la lógica de la política de reintento se ejecuta de forma asíncrona usando retryPolicy.ExecuteAsync(). Dentro de esta ejecución, se encadenan dos operaciones asíncronas: FetchDataFromExternalApiAsync() y GeneratePdfFromData(data).

Si FetchDataFromExternalApiAsync() falla (ya que está configurado intencionadamente para hacerlo con una excepción simulada), la política de reintento capturará la HttpRequestException, registrará el intento de reintento y volverá a intentar la operación.

El método FetchDataFromExternalApiAsync() simula la obtención de datos de una API externa con un retraso y arroja intencionalmente una HttpRequestException para simular solicitudes fallidas.