Gérer les fautes transitoires, les délais d'attente et les exceptions avec élégance est crucial pour construire des applications robustes et résilientes. Polly est une bibliothèque .NET populaire qui offre des capacités de résilience et de gestion des fautes transitoires. Parmi ses nombreuses fonctionnalités, la politique de "réessai" est l'une des plus largement utilisées.
Dans cet article, nous allons explorer la politique de réessai de Polly en C#, en examinant son utilisation, ses options de configuration, et en fournissant des exemples de code pratiques. Nous utiliserons également la Bibliothèque IronPDF pour la génération de PDF avec la tentative de réessai Polly pour générer un PDF des résultats de la demande de formulaire.
Le réessai Polly est une politique fournie par la bibliothèque Polly qui permet aux développeurs de réessayer automatiquement des opérations qui pourraient échouer en raison d'une erreur ou de fautes transitoires. Les fautes transitoires sont des erreurs temporaires qui surviennent en raison de problèmes de réseau, d'une indisponibilité de service ou d'autres problèmes transitoires.
Avec la politique de réessai de Polly, vous pouvez définir des règles pour réessayer des opérations, y compris le nombre maximum de réessais, le délai entre plusieurs réessais, et les conditions de réessai d'une demande échouée. Cela aide à construire des applications résilientes qui peuvent se rétablir des échecs temporaires sans planter ou causer des perturbations pour les utilisateurs finaux.
Avant de plonger dans les exemples de code, comprenons comment installer et configurer Polly dans un projet C#.
Vous pouvez installer Polly via la Console du Gestionnaire de Packages NuGet en utilisant la commande suivante :
Ou via .NET CLI :
Dans votre fichier C#, incluez l'espace de noms Polly :
using Polly;Imports PollyCommençons par un exemple simple dans lequel nous réessayons une opération qui simule la récupération de données d'un service distant. Nous allons mettre en place une politique de réessai avec un maximum de 3 réessais et un délai de temporisation fixe de 2 secondes entre les réessais.
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 NamespaceDans cet exemple :
Handle<HttpRequestException>() spécifie que nous voulons gérer HttpRequestException et réessayer l'opération si cela se produit.WaitAndRetry() configure la politique de réessai avec 3 tentatives et un délai fixe de 2 secondes entre les tentatives (durée maximale spécifiée).onRetry délègue l'enregistrement d'un message lorsqu'un réessai se produit.
Le recul exponentiel est une stratégie de réessai populaire où le délai entre les demandes et les réessais augmente de façon exponentielle. Polly offre un moyen pratique d'implémenter le backoff exponentiel en utilisant 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)
Combiner le réessai avec un disjoncteur peut améliorer davantage la résilience en empêchant les réessais répétés lorsqu'un service échoue constamment. Polly vous permet de combiner facilement les politiques de réessai et de disjoncteur.
// 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)Dans cet exemple :
CircuitBreaker() définit une politique de disjoncteur qui s'active après 3 exceptions et reste ouverte pendant 30 secondes.Policy.Wrap() combine les politiques de disjoncteur et de réessai en une seule politique.
L'aperçu de la bibliothèque IronPDF C# PDF est une puissante bibliothèque C# qui permet aux développeurs de créer, modifier et manipuler des documents PDF dans leurs applications .NET. Que vous ayez besoin de créer des factures, des rapports ou tout autre type de document PDF, IronPDF fournit une API intuitive qui simplifie le processus.
Avec IronPDF, vous pouvez facilement convertir des pages HTML, CSS et même ASP.NET en PDF, ce qui en fait un outil polyvalent pour un large éventail d'applications. De plus, il offre des fonctionnalités avancées telles que l'ajout de texte, d'images et d'éléments interactifs aux PDF, ainsi que leur sécurisation avec un cryptage et des signatures numériques.
IronPDF excelle dans la conversion HTML en PDF, garantissant la préservation précise des mises en page et des styles originaux. Il est parfait pour générer des PDF à partir de contenu web tel que des rapports, des factures et de la documentation. IronPDF prend en charge la conversion de fichiers HTML, d'URL et de chaînes HTML brutes en fichiers PDF de haute qualité.
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 ClassLorsque vous travaillez avec IronPDF, il peut y avoir des scénarios où vous devez obtenir des données de sources externes ou effectuer des opérations complexes avant de générer un PDF.
Dans de tels cas, vous pourriez rencontrer des fautes transitoires ou des problèmes temporaires qui pourraient entraîner des échecs de génération de PDF. Pour gérer ces fautes transitoires avec élégance, vous pouvez utiliser Polly Retry en conjonction avec IronPDF.
Avant de commencer, assurez-vous d'installer le package NuGet IronPDF dans votre projet.
Regardons un exemple où nous utilisons Polly Retry pour gérer les fautes transitoires lors de la génération d'un PDF avec IronPDF. Dans l'exemple suivant, nous allons simuler la récupération de données d'une API externe, puis générer un PDF à partir de ces données. Nous utiliserons Polly Retry pour exécuter l'opération de récupération de données en cas d'échecs.
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 NamespaceCe code C# démontre comment utiliser la bibliothèque Polly pour implémenter des politiques de réessai avec IronPDF pour générer un document PDF. La méthode Main initialise une politique de réessai utilisant la méthode WaitAndRetryAsync de Polly.
Cette politique spécifie qu'elle doit gérer HttpRequestException et réessayer l'opération jusqu'à 3 fois avec un délai de 2 secondes entre la tentative initiale et les réessais. Si un échec de réessai se produit, un message est imprimé sur la console indiquant le numéro de la tentative de réessai et le message d'exception.
À l'intérieur de la méthode Main, la logique de la politique de réessai est exécutée de manière asynchrone en utilisant retryPolicy.ExecuteAsync(). Dans cette exécution, deux opérations asynchrones sont enchaînées ensemble : FetchDataFromExternalApiAsync() et GeneratePdfFromData(data).
Si FetchDataFromExternalApiAsync() échoue (comme il est intentionnellement configuré pour le faire avec une exception simulée), la politique de réessai interceptera HttpRequestException, enregistrera la tentative de réessai et réessayera l'opération.
La méthode FetchDataFromExternalApiAsync() simule la récupération de données à partir d'une API externe avec un délai et lance intentionnellement une HttpRequestException pour simuler des demandes échouées.
En conclusion, la politique de réessai de Polly s'avère inestimable pour gérer les fautes transitoires et assurer la robustesse des applications C#. Sa flexibilité dans la configuration des tentatives de réessai, des délais et des conditions permet aux développeurs d'adapter les stratégies de résilience à des exigences spécifiques.
Que ce soit utilisé indépendamment ou en conjonction avec des bibliothèques comme IronPDF, Polly facilite la création d'applications qui se rétablissent gracieusement des échecs temporaires, améliorant l'expérience utilisateur et la fiabilité du logiciel.
En intégrant les capacités de réessai de Polly, les développeurs peuvent construire des systèmes plus résilients qui peuvent s'adapter et se rétablir des problèmes transitoires, améliorant finalement la qualité et la fiabilité globale de leurs applications.
IronPDF est la meilleure bibliothèque PDF C# sur le marché, elle propose également une licence d'essai pour IronPDF, les prix commencent à partir de $999 USD.
Pour en savoir plus sur la conversion HTML en PDF avec IronPDF, visitez le tutoriel de conversion HTML en PDF IronPDF.
Jacob Mellor est directeur de la technologie chez Iron Software et un ingénieur visionnaire pionnier de la technologie C# PDF. En tant que développeur à l'origine de la base de code centrale d'Iron Software, il a façonné l'architecture des produits de l'entreprise depuis sa création, la transformant aux côtés du PDG Cameron Rimington en une entreprise de plus de 50 personnes au service de la NASA, de Tesla et d'agences gouvernementales mondiales.
IronPDF fait partie de IRONSUITE
10 API .NET pour vos documents
Lorsque vous avez besoin que votre PDF ressemble à HTML, rapidement.
