Pruebas en un entorno real
Pruebe en producción sin marcas de agua.
Funciona donde lo necesites.
Polly es una librería .NET de estrategias de resiliencia y gestión de fallos transitorios, que permite a los desarrolladores expresar políticas de resiliencia como la política de reintentos, disyuntores, tiempos de espera, política de aislamiento de mamparos y Fallback. Polly está orientado a ASP.NET Core, lo que lo convierte en una herramienta vital para la resiliencia de .NET Core. Polly tiene un modo seguro para hilos y soporta el manejo de múltiples peticiones concurrentes con respuesta exitosa.
Este tutorial proporcionará más detalles sobre el manejo de fallos transitorios .NET biblioteca, Polly y cómo usarlo con IronPDF en una aplicación ASP.NET Core. Nos sumergiremos en profundidad en cada aspecto de Polly, explicaremos la mecánica del patrón de interruptores, discutiremos el aislamiento de mamparos y los tiempos de espera, y mostraremos cómo manejar excepciones específicas o fallos de servicio con respuesta a fallos de una manera segura y controlada.
Los fallos transitorios suelen producirse cuando su aplicación intenta conectarse con un servicio web a través de una petición HTTP, una base de datos u otros recursos externos. Estos fallos, como los fallos de red, los problemas temporales de conectividad o los tiempos de espera, son breves y suelen corregirse solos al cabo de poco tiempo.
Polly gestiona estos fallos transitorios aplicando diferentes estrategias y políticas expresas como la política de reintentos, la política avanzada de disyuntores, la política de tiempos de espera, la política de Fallback y la política de aislamiento de mamparas.
La política de reintentos reintenta automáticamente las solicitudes concurrentes fallidas utilizando la lógica de reintentos. Puede configurarse para que reintente siempre o para que reintente automáticamente un determinado número de veces, y puede esperar un intervalo de tiempo determinado entre reintentos o utilizar un retardo exponencial.
La política Circuit Breaker permite que su sistema admita el token de cancelación para intentar un servicio concreto tras un umbral preconfigurado de solicitudes fallidas. La estrategia del disyuntor es análoga a la ingeniería del caos o a un barco que cierra las puertas estancas para localizar los daños: un fallo no hundirá todo el barco.
La política de tiempo de espera impone un tiempo máximo de ejecución de un determinado fragmento de código de resiliencia .NET. Hay dos tipos: tiempo de espera optimista y tiempo de espera pesimista.
La política de Fallback se utiliza para proporcionar un valor o comportamiento sustitutivo en caso de fallo. Esta política puede ser útil cuando un servicio que falla no debe detener todo el proceso.
El aislamiento masivo se utiliza para limitar el número de peticiones concurrentes que se pueden hacer a una operación específica, limitando así el potencial de agotamiento del socket y manteniendo un número controlado de ranuras de ejecución.
La política de caché almacena en caché la respuesta satisfactoria de una ejecución, de modo que si se vuelve a invocar la misma ejecución, Polly puede devolver el valor de caché distribuido.
Permite agrupar varias pólizas para que funcionen como una sola.
Una política de reintento es simple: cuando se produce una excepción específica o un fallo, Polly intentará ejecutar de nuevo el delegado subyacente. Puedes definir cuántas veces reintentar, el intervalo de tiempo entre reintentos, o utilizar una estrategia de retroceso exponencial, de lo contrario reintentará para siempre. He aquí un ejemplo:
//extension method
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
});
//extension method
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
});
'extension method
Dim retryPolicy = Policy.Handle(Of HttpRequestException)().WaitAndRetryAsync(3, Function(retryAttempt) TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), Sub(exception, timeSpan, retryCount, context)
End Sub)
La política de Interruptor de Circuito permite a la biblioteca Polly monitorizar los fallos, y si el número de fallos excede un umbral configurado dentro de un periodo especificado, el circuito se "rompe", y se bloquean más peticiones durante un tiempo especificado. Esto se denomina estado "abierto". Transcurrido este tiempo, el circuito entra en un estado "semiabierto", en el que permite cierto tráfico para comprobar la salud del servicio en cuestión. Si estas solicitudes tienen éxito y no se producen fallos, el circuito se cierra; en caso contrario, se abre de nuevo.
var circuitBreakerPolicy = Policy
.Handle<HttpRequestException>()
.CircuitBreakerAsync(5, TimeSpan.FromMinutes(1));
var circuitBreakerPolicy = Policy
.Handle<HttpRequestException>()
.CircuitBreakerAsync(5, TimeSpan.FromMinutes(1));
Dim circuitBreakerPolicy = Policy.Handle(Of HttpRequestException)().CircuitBreakerAsync(5, TimeSpan.FromMinutes(1))
Las políticas de tiempo de espera gestionan situaciones en las que un servicio no responde en un plazo 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 padre hasta que la operación se completa o transcurre el periodo de tiempo de espera.
var timeoutPolicy = Policy.TimeoutAsync(30); // Optimistic timeout of 30 seconds
var timeoutPolicy = Policy.TimeoutAsync(30); // Optimistic timeout of 30 seconds
IRON VB CONVERTER ERROR developers@ironsoftware.com
El aislamiento de mamparos se utiliza para limitar el número de acciones concurrentes contra un servicio concreto. Proporciona una forma de aislar los fallos y evitar que se produzcan en cascada. También limita la carga que imponemos a nuestras dependencias.
var bulkheadIsolationPolicy = Policy.BulkheadAsync(10, 20); // 10 concurrent actions, queue 20 additional actions
var bulkheadIsolationPolicy = Policy.BulkheadAsync(10, 20); // 10 concurrent actions, queue 20 additional actions
IRON VB CONVERTER ERROR developers@ironsoftware.com
Las políticas de emergencia son útiles cuando se necesita proporcionar un comportamiento por defecto o un valor sustitutivo cuando todo lo demás falla.
var fallbackPolicy = Policy
.Handle<Exception>()
.FallbackAsync<FallbackResult>(FallbackResult.SomethingWentWrong);
var fallbackPolicy = Policy
.Handle<Exception>()
.FallbackAsync<FallbackResult>(FallbackResult.SomethingWentWrong);
Dim fallbackPolicy = Policy.Handle(Of Exception)().FallbackAsync(Of FallbackResult)(FallbackResult.SomethingWentWrong)
Se pueden combinar varias políticas de forma flexible utilizando un PolicyWrap
:
var policyWrap = Policy.WrapAsync(fallbackPolicy, retryPolicy, circuitBreakerPolicy, timeoutPolicy, bulkheadIsolationPolicy);
var policyWrap = Policy.WrapAsync(fallbackPolicy, retryPolicy, circuitBreakerPolicy, timeoutPolicy, bulkheadIsolationPolicy);
IRON VB CONVERTER ERROR developers@ironsoftware.com
Para empezar a utilizar Polly con IronPDF, asegúrese de tener Visual Studio instalado y cree un nuevo proyecto de aplicación de consola en .NET Core. Abre la consola del gestor de paquetes NuGet en Visual Studio e instala los paquetes Polly
e IronPdf
:
Install-Package Polly
Install-Package IronPdf
Una característica destacada de IronPDF es su HTML a PDF garantizando que los diseños y estilos permanezcan intactos. Esta función convierte el contenido web en PDF, lo que resulta perfecto para informes, facturas y documentación. Permite convertir archivos HTML, URL y cadenas HTML a PDF.
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");
}
}
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 Class
Veamos un ejemplo del uso de Polly con IronPDF para convertir una URL en PDF. Supongamos que tenemos un servicio web que ocasionalmente falla debido a fallos transitorios, y queremos manejar esos fallos con gracia usando Polly.
En primer lugar, vamos a importar los espacios de nombres necesarios en nuestro archivo Program.cs
:
using System;
using System.Threading.Tasks;
using Polly;
using Polly.Wrap;
using IronPdf;
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 IronPdf
A continuación, definiremos nuestras políticas. En este ejemplo, utilizaremos una combinación de políticas de reintento y disyuntor para gestionar los fallos:
var retryPolicy = Policy
.Handle<Exception>()
.WaitAndRetryAsync(3, i => TimeSpan.FromSeconds(2 * i));
var circuitBreakerPolicy = Policy
.Handle<Exception>()
.CircuitBreakerAsync(2, TimeSpan.FromSeconds(30));
var retryPolicy = Policy
.Handle<Exception>()
.WaitAndRetryAsync(3, i => TimeSpan.FromSeconds(2 * i));
var circuitBreakerPolicy = Policy
.Handle<Exception>()
.CircuitBreakerAsync(2, TimeSpan.FromSeconds(30));
IRON VB CONVERTER ERROR developers@ironsoftware.com
La retryPolicy
reintentará la petición fallida hasta tres veces con una estrategia de backoff exponencial, esperando 2 segundos, 4 segundos y 8 segundos entre reintentos. La circuitBreakerPolicy
abrirá el circuito si se producen dos fallos consecutivos en un intervalo de tiempo de 30 segundos.
Ahora, definamos nuestro código IronPDF para convertir una URL en un PDF:
var htmlToPdf = new ChromePdfRenderer();
var pdfBytes = await retryPolicy
.WrapAsync(circuitBreakerPolicy)
.ExecuteAsync(() =>
{
Console.WriteLine("Attempting to convert URL to PDF...");
// var result
var result = htmlToPdf.RenderUrlAsPdfAsync("https://example.com");
Console.WriteLine("Conversion successful!");
return result;
});
pdfBytes.SaveAs("output.pdf");
var htmlToPdf = new ChromePdfRenderer();
var pdfBytes = await retryPolicy
.WrapAsync(circuitBreakerPolicy)
.ExecuteAsync(() =>
{
Console.WriteLine("Attempting to convert URL to PDF...");
// var result
var result = htmlToPdf.RenderUrlAsPdfAsync("https://example.com");
Console.WriteLine("Conversion successful!");
return result;
});
pdfBytes.SaveAs("output.pdf");
IRON VB CONVERTER ERROR developers@ironsoftware.com
En el código de ejemplo anterior, envolvemos nuestra retryPolicy
y circuitBreakerPolicy
utilizando el método WrapAsync
. Esto nos permite aplicar varias políticas a las nuevas solicitudes de forma 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 Polly, nos aseguramos de que nuestro código es resistente a los fallos transitorios. Si una solicitud falla, Polly la reintentará automáticamente de acuerdo con la política de reintentos. Si el número de fallos consecutivos supera el umbral preconfigurado, la política de interruptores abrirá el circuito, impidiendo nuevas solicitudes durante un tiempo determinado.
Para probar la eficacia de nuestras políticas Polly, vamos a simular algunas peticiones fallidas. Modifica la URL a un endpoint inexistente y añade 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}");
}
}
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}");
}
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
En el código anterior, iteramos sobre un conjunto de URL de prueba e intentamos convertir cada una de ellas a PDF. Si una solicitud falla, se capturará la excepción y se mostrará un mensaje apropiado en la consola.
Polly es una biblioteca potente y flexible para implementar la resiliencia y la gestión de fallos transitorios en aplicaciones .NET Core. Combinando políticas como el reintento y el disyuntor, los desarrolladores pueden crear sistemas robustos y tolerantes a fallos que los gestionen con elegancia.
En este tutorial, exploramos cómo utilizar Polly con IronPDF para convertir una URL a PDF. Aprendimos a definir y aplicar políticas Polly, incluyendo reintento y disyuntor. También probamos nuestras políticas con diferentes URL. También podemos hacerlo para convertir HTML a PDF.
IronPDF ofrece un prueba gratuitay las licencias comienzan a partir de $749, lo que le permite aprovechar sus capacidades en sus proyectos.
9 productos API .NET para sus documentos de oficina