.NET Core Polly (Cómo funciona para desarrolladores)

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 es seguro para hilos y admite la gestión de múltiples solicitudes simultáneas con respuestas satisfactorias.

Este tutorial proporcionará más detalles sobre la biblioteca .NET de gestión de fallos transitorios, Polly, y cómo utilizarla conIronPDF en una aplicación ASP.NET Core. Profundizaremos 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 respuestas de fallo de forma controlada y segura para los hilos.

Políticas de Polly

Los fallos transitorios suelen producirse cuando la aplicación intenta conectarse con un servicio web a través de una solicitud 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 expresando políticas como Retry Policy, advanced Circuit Breaker Policy, Timeout Policy, Fallback Policy y Bulkhead Isolation Policy.

Política de reintentos

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.

Interruptor automático

La política Circuit Breaker permite que su sistema admita un 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.

Política de plazos

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.

Política de emergencia

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.

Aislamiento de mamparos

El aislamiento masivo se utiliza para limitar el número de solicitudes simultáneas 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.

Política de caché

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.

Política

Permite agrupar varias pólizas para que funcionen como una sola.

Crear y configurar políticas

Política de reintentos

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)

Política de disyuntores

La política Circuit Breaker permite a la biblioteca Polly monitorizar los fallos y, si el número de fallos supera un umbral configurado en un periodo determinado, 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 peticiones tienen éxito y no se producen fallos, el circuito se cierra; si no, 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))

Política de plazos

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

Aislamiento de mamparos

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

Política de emergencia

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)

Envolver las políticas

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

Primeros pasos

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

:ProductInstall Install-Package IronPdf

Uso de Polly con IronPDF Conversión de una URL a PDF

Una característica destacada de IronPDF es suCapacidad de conversión de HTML a PDFademás, debe garantizar que los diseños y estilos se mantengan 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 paraconvertir 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));

Dim retryPolicy = Policy.Handle(Of Exception)().WaitAndRetryAsync(3, Function(i) TimeSpan.FromSeconds(2 * i))

Dim circuitBreakerPolicy = Policy.Handle(Of Exception)().CircuitBreakerAsync(2, TimeSpan.FromSeconds(30))

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 = 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 = 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(Function()
		Console.WriteLine("Attempting to convert URL to PDF...")
		Dim result = 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 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.

Casos de prueba de las políticas de Polly

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.

Conclusión

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 paraconvertir HTML a PDF.

IronPDF ofrece unprueba gratuita, y las licencias comienzan a precios competitivos, lo que le permite aprovechar sus capacidades en sus proyectos.