Polly es una biblioteca de estrategias de resiliencia y manejo de fallas transitorias en .NET, que permite a los desarrolladores expresar políticas de resiliencia como política de reintento, interruptores automáticos, tiempo de espera, política de aislamiento de compartimentos y reserva. Polly tiene como objetivo ASP.NET Core, convirtiéndose en una herramienta vital para la resiliencia de .NET Core. Polly es seguro para el uso de hilos y admite el manejo de múltiples solicitudes concurrentes con respuestas exitosas.
Este tutorial proporcionará más detalles sobre la biblioteca de manejo de fallas transitorias .NET, Polly, y cómo usarla con IronPDF en una aplicación ASP.NET Core. Profundizaremos en cada aspecto de Polly, explicaremos la mecánica del patrón de interruptor automático, discutiremos el aislamiento de compartimentos y los tiempos de espera, y mostraremos cómo manejar excepciones específicas o servicios fallidos con respuestas de falla de manera controlada y segura para usar con hilos.
Las fallas transitorias a menudo ocurren cuando tu aplicación intenta conectarse con un servicio web a través de una solicitud HTTP, base de datos u otros recursos externos. Estas fallas, como fallas de red, problemas de conectividad temporales o tiempos de espera, son breves y generalmente se corrigen solos después de un corto tiempo.
Polly gestiona estas fallas transitorias aplicando diferentes estrategias y expresando políticas como la política de reintento, política avanzada de interruptor automático, política de tiempo de espera, política de reserva y política de aislamiento de compartimentos.
La política de reintento reintenta automáticamente solicitudes concurrentes fallidas utilizando lógica de reintento. Se puede configurar para reintentar indefinidamente o hacer reintentos automáticos por un número determinado de veces, y puede esperar un intervalo de tiempo establecido entre reintentos o usar una retroalimentación exponencial.
La política de interruptor automático permite que tu sistema admita un token de cancelación para intentar un servicio particular después de un umbral preconfigurado de solicitudes fallidas. La estrategia del interruptor automático es análoga a la ingeniería del caos o un barco cerrando puertas herméticas para localizar daños: una falla no hundirá todo el barco.
La política de tiempo de espera impone un tiempo máximo que una pieza particular del código de resiliencia de .NET puede ejecutarse. Viene en dos variantes: tiempo de espera optimista y tiempo de espera pesimista.
La política de reserva se utiliza para proporcionar un valor o comportamiento sustituto en caso de falla. Esta política puede ser útil cuando un servicio fallido no debe detener todo el proceso.
El aislamiento de compartimentos se utiliza para limitar cuántas solicitudes concurrentes se pueden hacer a una operación específica, limitando así el potencial de agotamiento de sockets y manteniendo un número controlado de espacios de ejecución.
La política de caché almacena en caché la respuesta exitosa de una ejecución para que si se invoca nuevamente la misma ejecución, Polly pueda devolver el valor de la caché distribuida.
Nos permite agrupar múltiples políticas juntas para que puedan funcionar como una sola unidad.
Una política de reintento es simple: cuando ocurre una excepción específica o una falla, Polly intentará ejecutar el delegado subyacente nuevamente. Puedes definir cuántas veces reintentar, el intervalo de tiempo entre reintentos o usar una estrategia de retroalimentación exponencial, de lo contrario, intentará indefinidamente. Aquí hay un ejemplo:
// Retry policy for handling HttpRequestException with exponential back-off
var retryPolicy = Policy
.Handle<HttpRequestException>()
.WaitAndRetryAsync(3, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)),
(exception, timeSpan, retryCount, context) =>
{
// This is the OnRetry delegate, where you can log or monitor failed requests
Console.WriteLine($"Retry {retryCount} after {timeSpan}. Exception: {exception.Message}");
});' Retry policy for handling HttpRequestException with exponential back-off
Dim retryPolicy = Policy.Handle(Of HttpRequestException)().WaitAndRetryAsync(3, Function(retryAttempt) TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), Sub(exception, timeSpan, retryCount, context)
Console.WriteLine($"Retry {retryCount} after {timeSpan}. Exception: {exception.Message}")
End Sub)La política de interruptor automático permite que la biblioteca Polly monitoree las fallas, y si el número de fallas excede un umbral configurado dentro de un período específico, el circuito se 'rompe' y se bloquean más solicitudes por un tiempo especificado. Esto se llama estado 'abierto'. Después de este tiempo, el circuito entra en un estado 'medio abierto', donde permite algo de tráfico para verificar la salud del servicio particular. Si estas solicitudes tienen éxito y no ocurren fallas, el circuito se cierra; de lo contrario, se abre nuevamente.
// Circuit breaker policy to handle failing requests with open and half-open states
var circuitBreakerPolicy = Policy
.Handle<HttpRequestException>()
.CircuitBreakerAsync(5, TimeSpan.FromMinutes(1));' Circuit breaker policy to handle failing requests with open and half-open states
Dim circuitBreakerPolicy = Policy.Handle(Of HttpRequestException)().CircuitBreakerAsync(5, TimeSpan.FromMinutes(1))Las políticas de tiempo de espera manejan escenarios donde un servicio no responde dentro de un marco de tiempo razonable. Polly ofrece dos tipos de tiempos de espera: Optimista y Pesimista. Un tiempo de espera optimista funciona en un hilo separado y cancela la operación subyacente a través de un CancellationToken. Un tiempo de espera pesimista bloquea el hilo principal hasta que la operación se complete o finalice el período de tiempo de espera.
// Timeout policy with a 30-second optimistic timeout
var timeoutPolicy = Policy.TimeoutAsync(30); // 30 seconds' Timeout policy with a 30-second optimistic timeout
Dim timeoutPolicy = Policy.TimeoutAsync(30) ' 30 secondsEl aislamiento de compartimentos se utiliza para limitar el número de acciones concurrentes contra un servicio particular. Proporciona una forma de aislar fallas y evitar que se propaguen. También limita la carga que ponemos en nuestras dependencias.
// Bulkhead isolation policy to limit concurrency and queue length
var bulkheadIsolationPolicy = Policy.BulkheadAsync(10, 20); // 10 concurrent actions, 20 queue slots' Bulkhead isolation policy to limit concurrency and queue length
Dim bulkheadIsolationPolicy = Policy.BulkheadAsync(10, 20) ' 10 concurrent actions, 20 queue slotsLas políticas de reserva son útiles cuando necesitas proporcionar un comportamiento predeterminado o un valor sustituto cuando todo lo demás falla.
// Fallback policy to provide a default result on failure
var fallbackPolicy = Policy
.Handle<Exception>()
.FallbackAsync<FallbackResult>(
FallbackResult.SomethingWentWrong,
(exception, context) =>
{
Console.WriteLine($"Fallback triggered due to: {exception.Message}");
return Task.CompletedTask;
});' Fallback policy to provide a default result on failure
Dim fallbackPolicy = Policy.Handle(Of Exception)().FallbackAsync(Of FallbackResult)(FallbackResult.SomethingWentWrong, Function(exception, context)
Console.WriteLine($"Fallback triggered due to: {exception.Message}")
Return Task.CompletedTask
End Function)Se pueden combinar múltiples políticas de forma flexible utilizando un PolicyWrap:
// Combining multiple policies using PolicyWrap
var policyWrap = Policy.WrapAsync(fallbackPolicy, retryPolicy, circuitBreakerPolicy, timeoutPolicy, bulkheadIsolationPolicy);' Combining multiple policies using PolicyWrap
Dim policyWrap = Policy.WrapAsync(fallbackPolicy, retryPolicy, circuitBreakerPolicy, timeoutPolicy, bulkheadIsolationPolicy)Para comenzar a usar Polly con IronPDF, asegúrate de tener instalado Visual Studio y crea un nuevo proyecto de Aplicación de Consola en .NET Core. Abra la consola del Administrador de paquetes NuGet en Visual Studio e instale los paquetes Polly y IronPDF:
Una característica destacada de IronPDF es su capacidad de HTML a PDF, asegurando que los diseños y estilos se mantengan intactos. Esta función convierte contenido web en PDFs, lo que es perfecto para informes, facturas y documentación. Admite la conversión de archivos HTML, URLs y cadenas HTML a PDFs.
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 ClassVeamos un ejemplo de uso de Polly con IronPDF para convertir una URL a PDF. Supón que tenemos un servicio web que ocasionalmente falla debido a fallas transitorias, y queremos manejar esas fallas de manera elegante usando Polly.
Primero, importemos los espacios de nombres necesarios en nuestro archivo Program.cs:
using System;
using System.Threading.Tasks;
using Polly;
using Polly.Wrap;
using IronPdf;Imports System
Imports System.Threading.Tasks
Imports Polly
Imports Polly.Wrap
Imports IronPdfA continuación, definiremos nuestras políticas. En este ejemplo, usaremos una combinación de políticas de reintento e interruptor automático para manejar fallas:
// Retry policy with exponential backoff
var retryPolicy = Policy
.Handle<Exception>()
.WaitAndRetryAsync(3, i => TimeSpan.FromSeconds(2 * i));
// Circuit breaker policy to block requests after consecutive failures
var circuitBreakerPolicy = Policy
.Handle<Exception>()
.CircuitBreakerAsync(2, TimeSpan.FromSeconds(30));' Retry policy with exponential backoff
Dim retryPolicy = Policy.Handle(Of Exception)().WaitAndRetryAsync(3, Function(i) TimeSpan.FromSeconds(2 * i))
' Circuit breaker policy to block requests after consecutive failures
Dim circuitBreakerPolicy = Policy.Handle(Of Exception)().CircuitBreakerAsync(2, TimeSpan.FromSeconds(30))El retryPolicy reintentará la solicitud fallida hasta tres veces con una estrategia de retroceso exponencial, esperando 2 segundos, 4 segundos y 8 segundos entre reintentos. El circuitBreakerPolicy abrirá el circuito si ocurren dos fallos consecutivos dentro de un intervalo de tiempo de 30 segundos.
Ahora, definamos nuestro código de IronPDF para convertir una URL a un PDF:
var htmlToPdf = new ChromePdfRenderer();
var pdfBytes = await retryPolicy
.WrapAsync(circuitBreakerPolicy)
.ExecuteAsync(async () =>
{
Console.WriteLine("Attempting to convert URL to PDF...");
var result = await htmlToPdf.RenderUrlAsPdfAsync("https://example.com");
Console.WriteLine("Conversion successful!");
return result;
});
pdfBytes.SaveAs("output.pdf");Dim htmlToPdf = New ChromePdfRenderer()
Dim pdfBytes = Await retryPolicy.WrapAsync(circuitBreakerPolicy).ExecuteAsync(Async Function()
Console.WriteLine("Attempting to convert URL to PDF...")
Dim result = Await htmlToPdf.RenderUrlAsPdfAsync("https://example.com")
Console.WriteLine("Conversion successful!")
Return result
End Function)
pdfBytes.SaveAs("output.pdf")En el código de ejemplo anterior, envolvemos nuestro retryPolicy y circuitBreakerPolicy utilizando el método WrapAsync. Esto nos permite aplicar múltiples políticas a nuevas solicitudes de manera secuencial. El método ExecuteAsync ejecuta el delegado proporcionado, que en este código es el método RenderUrlAsPdfAsync de IronPDF.
Aplicando las políticas de Polly, aseguramos que nuestro código sea resistente a fallas transitorias. Si una solicitud falla, Polly la reintentará automáticamente según la política de reintento. Si el número de fallas consecutivas cruza el umbral preconfigurado, la política de interruptor automático abrirá el circuito, previniendo más solicitudes por una duración especificada.
Para probar la efectividad de nuestras políticas de Polly, simulemos algunas solicitudes fallidas. Modifica la URL a un punto final inexistente y agrega algunos casos de prueba:
var testUrls = new[]
{
"https://ironpdf.com",
"https://notexistingdomain.com/",
"http://httpbin.org/delay/120"
};
foreach (var url in testUrls)
{
try
{
var pdfBytes = await retryPolicy
.WrapAsync(circuitBreakerPolicy)
.ExecuteAsync(() => htmlToPdf.RenderUrlAsPdfAsync(url));
pdfBytes.SaveAs($"{Guid.NewGuid()}.pdf");
Console.WriteLine($"Successfully converted {url} to PDF.");
}
catch (Exception ex)
{
Console.WriteLine($"Failed to convert {url} to PDF: {ex.Message}");
}
}Imports System
Dim testUrls = {
"https://ironpdf.com",
"https://notexistingdomain.com/",
"http://httpbin.org/delay/120"
}
For Each url In testUrls
Try
Dim pdfBytes = Await retryPolicy _
.WrapAsync(circuitBreakerPolicy) _
.ExecuteAsync(Function() htmlToPdf.RenderUrlAsPdfAsync(url))
pdfBytes.SaveAs($"{Guid.NewGuid()}.pdf")
Console.WriteLine($"Successfully converted {url} to PDF.")
Catch ex As Exception
Console.WriteLine($"Failed to convert {url} to PDF: {ex.Message}")
End Try
NextEn el código anterior, iteramos un conjunto de URLs de prueba e intentamos convertir cada una de ellas a PDF. Si una solicitud falla, la excepción será capturada, y se mostrará un mensaje apropiado en la consola.
Polly es una biblioteca poderosa y flexible para implementar resiliencia y manejo de fallas transitorias en aplicaciones .NET Core. Combinando políticas como reintento e interruptor automático, los desarrolladores pueden construir sistemas robustos y tolerantes a fallas que manejan fallas de manera elegante.
En este tutorial, exploramos cómo usar Polly con IronPDF para convertir una URL a PDF. Aprendimos cómo definir y aplicar políticas de Polly, incluyendo reintento e interruptor automático. También probamos nuestras políticas con diferentes URLs. También podemos hacerlo para convertir HTML a PDF.
IronPDF ofrece una prueba gratuita, y las licencias comienzan a precios competitivos, lo que te permite aprovechar sus capacidades en tus proyectos.
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.
