Manejar fallas transitorias, tiempos de espera y excepciones de manera elegante es crucial para construir aplicaciones sólidas y resilientes. Polly es una popular biblioteca para .NET que proporciona capacidades de manejo de fallas transitorias y resiliencia. Entre sus muchas características, "retry" es una de las políticas más utilizadas.
En este artículo, profundizaremos en la política de reintentos de Polly en C#, explorando su uso, opciones de configuración y proporcionando ejemplos de código práctico. Además, utilizaremos la Biblioteca IronPDF para generación de PDF con el intento de reintento de Polly para generar un PDF de los resultados de solicitudes de formulario.
Polly Retry es una política proporcionada por la biblioteca Polly que permite a los desarrolladores reintentar automáticamente operaciones que podrían fallar debido a un error o fallas transitorias. Las fallas transitorias son errores temporales que ocurren debido a fallas de red, falta de disponibilidad del servicio u otros problemas transitorios.
Con la política de reintento de Polly, puedes definir reglas para reintentar operaciones, incluyendo el número máximo de reintentos, el retraso entre múltiples reintentos y las condiciones para volver a intentar una solicitud fallida. Esto ayuda a construir aplicaciones resilientes que puedan recuperarse de fallos temporales sin colapsar o causar interrupciones a los usuarios finales.
Antes de profundizar en ejemplos de código, establezcamos un entendimiento básico de cómo instalar y configurar Polly en un proyecto C#.
Puedes instalar Polly a través de la consola de administrador de paquetes NuGet usando el siguiente comando:
O a través de .NET CLI:
En tu archivo C#, incluye el espacio de nombres Polly:
using Polly;Imports PollyComencemos con un ejemplo simple donde reintentamos una operación que simula la obtención de datos de un servicio remoto. Configuraremos una política de reintento con un máximo de 3 reintentos y retraso fijo de tiempo de espera de 2 segundos entre reintentos.
using System;
using System.Net.Http;
using Polly;
namespace PollyRetryExample
{
public class Program
{
public static void Main(string[] args)
{
// Define a retry policy that handles HttpRequestException with a maximum of 3 retries
var retryPolicy = Policy
.Handle<HttpRequestException>() // Specify the exception type to handle
.WaitAndRetry(
3, // Max retry attempts
retryAttempt => TimeSpan.FromSeconds(2), // Fixed retry delay
(exception, timeSpan, retryCount, context) =>
{
Console.WriteLine("Retry {0} due to {1}", retryCount, exception.Message);
});
try
{
// Execute the action within the context of the retry policy
retryPolicy.Execute(() =>
{
FetchDataFromRemoteService();
});
}
catch (Exception ex)
{
Console.WriteLine("Failed after 3 retries: {0}", ex.Message);
}
}
// Simulate fetching data that throws HttpRequestException
public static void FetchDataFromRemoteService()
{
throw new HttpRequestException("Failed to fetch data from remote service");
}
}
}Imports System
Imports System.Net.Http
Imports Polly
Namespace PollyRetryExample
Public Class Program
Public Shared Sub Main(ByVal args() As String)
' Define a retry policy that handles HttpRequestException with a maximum of 3 retries
Dim retryPolicy = Policy.Handle(Of HttpRequestException)().WaitAndRetry(3, Function(retryAttempt) TimeSpan.FromSeconds(2), Sub(exception, timeSpan, retryCount, context)
Console.WriteLine("Retry {0} due to {1}", retryCount, exception.Message)
End Sub)
Try
' Execute the action within the context of the retry policy
retryPolicy.Execute(Sub()
FetchDataFromRemoteService()
End Sub)
Catch ex As Exception
Console.WriteLine("Failed after 3 retries: {0}", ex.Message)
End Try
End Sub
' Simulate fetching data that throws HttpRequestException
Public Shared Sub FetchDataFromRemoteService()
Throw New HttpRequestException("Failed to fetch data from remote service")
End Sub
End Class
End NamespaceEn este ejemplo:
Handle<HttpRequestException>() especifica que queremos manejar HttpRequestException y reintentar la operación si ocurre.WaitAndRetry() configura la política de reintento con 3 reintentos y un retraso fijo de 2 segundos entre reintentos (duración máxima especificada).onRetry delegado registra un mensaje cuando ocurre un reintento.
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 backoff 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}");
});Dim retryPolicy = Policy.Handle(Of HttpRequestException)().WaitAndRetry(retryCount:= 3, sleepDurationProvider:= Function(attempt) TimeSpan.FromSeconds(Math.Pow(2, attempt)), onRetry:= Sub(exception, timeSpan, retryCount, context)
Console.WriteLine($"Retry {retryCount} due to {exception.Message}")
End Sub)
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
Dim circuitBreakerPolicy = Policy.Handle(Of HttpRequestException)().CircuitBreaker(exceptionsAllowedBeforeBreaking:= 3, durationOfBreak:= TimeSpan.FromSeconds(30), onBreak:= Sub(ex, breakDelay)
Console.WriteLine($"Circuit broken due to {ex.Message}. Retry after {breakDelay.TotalSeconds} seconds.")
End Sub, onReset:= Sub()
Console.WriteLine("Circuit reset.")
End Sub)
' Define a retry policy
Dim retryPolicy = Policy.Handle(Of HttpRequestException)().WaitAndRetry(retryCount:= 3, sleepDurationProvider:= Function(attempt) TimeSpan.FromSeconds(2), onRetry:= Sub(exception, timeSpan, retryCount, context)
Console.WriteLine($"Retry {retryCount} due to {exception.Message}")
End Sub)
' Combine both policies into a single policy wrap
Dim policyWrap = Policy.Wrap(circuitBreakerPolicy, retryPolicy)En este ejemplo:
CircuitBreaker() define una política de circuit breaker que se rompe después de 3 excepciones y permanece abierta por 30 segundos.Policy.Wrap() combina las políticas de circuit breaker y reintento en una sola política.
IronPDF C# PDF Library Overview es una poderosa biblioteca C# que permite a los desarrolladores crear, editar y manipular documentos PDF dentro de sus aplicaciones .NET. Ya sea que necesites crear facturas, informes o cualquier otro tipo de documento PDF, IronPDF proporciona una API intuitiva que simplifica el proceso.
Con IronPDF, puedes convertir fácilmente HTML, CSS e incluso páginas web de ASP.NET a PDF, lo que la convierte en una herramienta versátil para una amplia gama de aplicaciones. Además, ofrece características avanzadas como agregar texto, imágenes y elementos interactivos a PDFs, así como aseguraros con encriptación y firmas digitales.
IronPDF destaca en la conversión de HTML a PDF, asegurando la preservación precisa de los diseños y estilos originales. Es perfecto para generar PDFs a partir de contenido basado en la web, como informes, facturas y documentación. IronPDF admite la conversión de archivos HTML, URLs y cadenas HTML en bruto en archivos PDF de alta calidad.
using IronPdf;
class Program
{
static void Main(string[] args)
{
var renderer = new ChromePdfRenderer();
// 1. Convert HTML String to PDF
var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");
// 2. Convert HTML File to PDF
var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");
// 3. Convert URL to PDF
var url = "http://ironpdf.com"; // Specify the URL
var pdfFromUrl = renderer.RenderUrlAsPdf(url);
pdfFromUrl.SaveAs("URLToPDF.pdf");
}
}Imports IronPdf
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim renderer = New ChromePdfRenderer()
' 1. Convert HTML String to PDF
Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")
' 2. Convert HTML File to PDF
Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")
' 3. Convert URL to PDF
Dim url = "http://ironpdf.com" ' Specify the URL
Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
pdfFromUrl.SaveAs("URLToPDF.pdf")
End Sub
End ClassAl 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.
Antes de comenzar, asegúrate de instalar el paquete NuGet de IronPDF en tu proyecto.
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);
}
}
}Imports System
Imports System.Net.Http
Imports System.Threading.Tasks
Imports IronPdf
Imports Polly
Namespace IronPdfWithPollyRetry
Public Class Program
Public Shared Async Function Main(ByVal args() As String) As Task
' Define a retry policy with async capability
Dim retryPolicy = Policy.Handle(Of HttpRequestException)().WaitAndRetryAsync(3, Function(retryAttempt) TimeSpan.FromSeconds(2), Sub(exception, timeSpan, retryCount, context)
Console.WriteLine("Retry " & retryCount & " due to " & exception.Message)
End Sub)
' Execute the retry policy asynchronously
Dim pdf = Await retryPolicy.ExecuteAsync(Async Function()
Dim data = Await FetchDataFromExternalApiAsync() ' Fetch data from an external source
Return GeneratePdfFromData(data) ' Generate PDF using fetched data
End Function)
pdf.SaveAs("GeneratedDocument.pdf")
End Function
' Simulate fetching data from an external API
Private Shared Async Function FetchDataFromExternalApiAsync() As Task(Of String)
Await Task.Delay(100) ' Simulate delay
Throw New HttpRequestException("Failed to fetch data from external API")
End Function
' Generate PDF using IronPDF based on the fetched data
Private Shared Function GeneratePdfFromData(ByVal data As String) As PdfDocument
Dim htmlContent = "<html><body><h1>Data: " & data & "</h1></body></html>"
Dim renderer = New ChromePdfRenderer()
Return renderer.RenderHtmlAsPdf(htmlContent)
End Function
End Class
End NamespaceEste 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 manera asíncrona usando retryPolicy.ExecuteAsync(). Dentro de esta ejecución, dos operaciones asíncronas se encadenan juntas: FetchDataFromExternalApiAsync() y GeneratePdfFromData(data).
Si FetchDataFromExternalApiAsync() falla (como está configurado intencionalmente para hacerlo con una excepción simulada), la política de reintento capturará HttpRequestException, registrará el intento de reintento y reintentará la operación.
El método FetchDataFromExternalApiAsync() simula la obtención de datos de una API externa con un retraso y lanza intencionalmente un HttpRequestException para simular solicitudes fallidas.
En conclusión, la política de reintento de Polly resulta invaluable para manejar fallas transitorias y asegurar la robustez en aplicaciones C#. Su flexibilidad en la configuración de intentos de reintento, retrasos y condiciones permite a los desarrolladores adaptar estrategias de resiliencia a requisitos específicos.
Ya sea usado de manera independiente o en conjunto con bibliotecas como IronPDF, Polly facilita la creación de aplicaciones que se recuperan de manera elegante de fallos temporales, mejorando la experiencia del usuario y la fiabilidad del software.
Al integrar las capacidades de reintento de Polly, los desarrolladores pueden construir sistemas más resilientes que puedan adaptarse y recuperarse de problemas transitorios, mejorando en última instancia la calidad y fiabilidad de sus aplicaciones.
IronPDF es la mejor biblioteca PDF de C# en el mercado, también ofrece una licencia trial para IronPDF precios comienzan desde $999 USD.
Para aprender sobre la conversión de HTML a PDF usando IronPDF visita el siguiente Tutorial de Conversión de HTML a PDF con IronPDF.
Jacob Mellor es Director de Tecnología de Iron Software y un ingeniero visionario pionero en la tecnología C# PDF. Como desarrollador original de la base de código principal de Iron Software, ha dado forma a la arquitectura de productos de la empresa desde su creación, transformándola, junto con el director ejecutivo Cameron Rimington, en una empresa de más de 50 personas que presta servicios a la NASA, Tesla y organismos gubernamentales de todo el mundo.
IronPDF es parte de IRONSUITE
10 productos API .NET para tus documentos de oficina
Cuando necesitas que tu PDF se parezca al HTML, rápido.
