Lidar de forma adequada com falhas transitórias, timeouts e exceções é crucial para construir aplicações robustas e resilientes. Polly é uma biblioteca .NET popular que oferece resiliência e recursos de tratamento de falhas transitórias. Dentre suas muitas funcionalidades, "tentativa e erro" é uma das políticas mais utilizadas.
Neste artigo, vamos nos aprofundar na política de retry do Polly em C#, explorando seu uso, opções de configuração e fornecendo exemplos de código práticos. Além disso, utilizaremos a biblioteca IronPDF para geração de PDFs com a opção Polly Retry para gerar um PDF dos resultados da solicitação do formulário.
O Polly Retry é uma política fornecida pela biblioteca Polly que permite aos desenvolvedores repetir automaticamente operações que possam falhar devido a um erro ou falhas transitórias. Falhas transitórias são erros temporários que ocorrem devido a problemas de rede, indisponibilidade de serviço ou outros problemas transitórios.
Com a política de repetição do Polly, você pode definir regras para repetir operações, incluindo o número máximo de tentativas, o atraso entre várias tentativas e as condições para repetir uma solicitação com falha. Isso ajuda a criar aplicativos resilientes que podem se recuperar de falhas temporárias sem travar ou causar interrupções aos usuários finais.
Antes de mergulharmos nos exemplos de código, vamos estabelecer um entendimento básico de como instalar e configurar o Polly em um projeto C#.
Você pode instalar o Polly através do Console do Gerenciador de Pacotes NuGet usando o seguinte comando:
Ou via .NET CLI:
No seu arquivo C#, inclua o namespace Polly:
using Polly;Imports PollyVamos começar com um exemplo simples em que repetimos uma operação que simula a busca de dados de um serviço remoto. Configuraremos uma política de repetição com um máximo de 3 tentativas e um tempo limite fixo de 2 segundos entre elas.
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 NamespaceNeste exemplo:
Handle<HttpRequestException>() especifica que queremos lidar com HttpRequestException e tentar a operação novamente se ocorrer.WaitAndRetry() configura a política de retry com 3 tentativas e um atraso fixo de 2 segundos entre as tentativas (duração máxima especificada).onRetry delegado registra uma mensagem quando uma tentativa é feita novamente.
O recuo exponencial é uma estratégia popular de repetição em que o atraso entre as solicitações e as novas tentativas aumenta exponencialmente. Polly fornece uma maneira conveniente de implementar recuo 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)
A combinação de novas tentativas com um disjuntor pode aumentar ainda mais a resiliência, evitando novas tentativas quando um serviço apresenta falhas constantes. Polly permite combinar facilmente políticas de repetição e de disjuntor.
// 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)Neste exemplo:
CircuitBreaker() define uma política de disjuntor que quebra após 3 exceções e permanece aberta por 30 segundos.Policy.Wrap() combina as políticas de disjuntor e retry em uma única política.
Visão geral da biblioteca IronPDF C# para PDF: trata-se de uma poderosa biblioteca C# que permite aos desenvolvedores criar, editar e manipular documentos PDF em seus aplicativos .NET . Seja para criar faturas, relatórios ou qualquer outro tipo de documento PDF, o IronPDF oferece uma API intuitiva que simplifica o processo.
Com o IronPDF, você pode converter facilmente páginas web HTML, CSS e até mesmo ASP.NET em PDF, tornando-o uma ferramenta versátil para uma ampla gama de aplicações. Além disso, oferece recursos avançados, como adicionar texto, imagens e elementos interativos a PDFs, bem como protegê-los com criptografia e assinaturas digitais.
O IronPDF se destaca na conversão de HTML para PDF , garantindo a preservação precisa dos layouts e estilos originais. É perfeito para gerar PDFs a partir de conteúdo da web, como relatórios, faturas e documentação. O IronPDF suporta a conversão de arquivos HTML, URLs e strings HTML brutas em arquivos PDF de alta qualidade.
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 ClassAo trabalhar com o IronPDF, pode haver cenários em que você precise buscar dados de fontes externas ou executar operações complexas antes de gerar um PDF.
Nesses casos, você pode se deparar com falhas transitórias ou problemas temporários que podem levar a falhas na geração de PDFs. Para lidar com essas falhas transitórias de forma adequada, você pode usar o Polly Retry em conjunto com o IronPDF.
Antes de começar, certifique-se de instalar o pacote NuGet IronPDF em seu projeto.
Vejamos um exemplo em que usamos o Polly Retry para lidar com falhas transitórias ao gerar um PDF usando o IronPDF. No exemplo a seguir, simularemos a obtenção de dados de uma API externa e, em seguida, a geração de um PDF com base nesses dados. Usaremos Polly Retry para executar a operação de busca de dados em caso de falhas.
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# demonstra como usar a biblioteca Polly para implementar políticas de repetição com o IronPDF para gerar um documento PDF. O método Main inicializa uma política de retry usando o método WaitAndRetryAsync da Polly.
Esta política especifica que deve lidar com HttpRequestException e tentar a operação até 3 vezes com um atraso de 2 segundos entre a tentativa inicial e as tentativas. Caso ocorra uma falha na nova tentativa, uma mensagem será exibida no console indicando o número da nova tentativa e a mensagem de exceção.
Dentro do método Main, a lógica da política de retry é executada de forma assíncrona usando retryPolicy.ExecuteAsync(). Nesta execução, duas operações assíncronas são encadeadas: FetchDataFromExternalApiAsync() e GeneratePdfFromData(data).
Se FetchDataFromExternalApiAsync() falhar (como está intencionalmente configurado para fazer com uma exceção simulada), a política de retry capturará o HttpRequestException, registrará a tentativa de retry e tentará a operação novamente.
O método FetchDataFromExternalApiAsync() simula a busca de dados de uma API externa com um atraso e lança intencionalmente um HttpRequestException para simular solicitações falhadas.
Em conclusão, a política de repetição do Polly demonstra ser inestimável para lidar com falhas transitórias e garantir robustez em aplicações C#. Sua flexibilidade na configuração de tentativas de repetição, atrasos e condições permite que os desenvolvedores adaptem as estratégias de resiliência a requisitos específicos.
Seja usado de forma independente ou em conjunto com bibliotecas como o IronPDF , o Polly facilita a criação de aplicativos que se recuperam de falhas temporárias de forma eficiente, melhorando a experiência do usuário e a confiabilidade do software.
Ao integrar os recursos de repetição do Polly, os desenvolvedores podem construir sistemas mais resilientes, capazes de se adaptar e se recuperar de problemas transitórios, melhorando, em última análise, a qualidade e a confiabilidade geral de seus aplicativos.
IronPDF é a melhor biblioteca PDF C# do mercado, também oferece uma licença de teste para IronPDF e os preços começam a partir de $999 USD.
Para aprender sobre a conversão de HTML para PDF usando o IronPDF, visite o seguinte tutorial de conversão de HTML para PDF do IronPDF .
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.
IronPDF faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
Quando você precisa que seu PDF tenha a aparência de HTML, rapidamente.
