Polly est une bibliothèque de stratégies de résilience et de gestion des fautes transitoires pour .NET, permettant aux développeurs d'exprimer des politiques de résilience telles que la politique de réessai, les disjoncteurs, les délais d'attente, la politique d'isolation du cloisonnement, et la politique de secours. Polly cible ASP.NET Core, ce qui en fait un outil essentiel pour la résilience de .NET Core. Polly est sûr pour les threads et prend en charge la gestion de plusieurs requêtes concurrentes avec des réponses réussies.
Ce tutoriel fournira plus de détails sur la bibliothèque .NET de gestion des fautes transitoires, Polly, et comment l'utiliser avec IronPDF dans une application ASP.NET Core. Nous allons plonger dans chaque aspect de Polly, expliquer le fonctionnement du modèle de disjoncteur, discuter de l'isolation du cloisonnement et des délais d'attente, et montrer comment gérer des exceptions spécifiques ou des services défaillants avec des réponses d'échec de manière contrôlée et sûre pour les threads.
Les fautes transitoires se produisent souvent lorsque votre application essaie de se connecter à un service web via une requête HTTP, une base de données ou d'autres ressources externes. Ces fautes, comme les échecs de réseau, les problèmes temporaires de connectivité ou les délais d'attente, sont brèves et se corrigent généralement d'elles-mêmes après un court laps de temps.
Polly gère ces fautes transitoires en appliquant différentes stratégies et en exprimant des politiques telles que la politique de réessai, la politique de disjoncteur avancée, la politique de délai d'attente, la politique de secours, et la politique d'isolation du cloisonnement.
La politique de réessai relance automatiquement les requêtes concurrentes échouées en utilisant la logique de réessai. Elle peut être configurée pour réessayer indéfiniment ou effectuer des réessais automatiques un certain nombre de fois, et elle peut attendre un intervalle de temps défini entre les réessais ou utiliser une stratégie d'attente exponentielle.
La politique de disjoncteur permet à votre système de supporter un jeton d'annulation pour essayer un service particulier après un seuil prédéfini de requêtes échouées. La stratégie de disjoncteur est analogue à l'ingénierie du chaos ou à un navire fermant les portes étanches pour localiser les dégâts : une seule faute ne fera pas couler tout le navire.
La politique de délai d'attente impose un temps maximum que peut exécuter un morceau de code de résilience .NET particulier. Elle se décline en deux versions : délai d'attente optimiste et délai d'attente pessimiste.
La politique de secours est utilisée pour fournir une valeur ou un comportement de substitution en cas d'échec. Cette politique peut être utile lorsque le service défaillant ne doit pas arrêter l'ensemble du processus.
L'isolation du cloisonnement est utilisée pour limiter combien de requêtes concurrentes peuvent être effectuées sur une opération spécifique, limitant ainsi le potentiel d'épuisement des sockets et maintenant un nombre contrôlé de créneaux d'exécution.
La politique de cache met en cache la réponse réussie d'une exécution afin que si la même exécution est invoquée à nouveau, Polly puisse renvoyer la valeur du cache distribué.
Permet de regrouper plusieurs politiques ensemble, afin qu'elles puissent fonctionner comme une unité unique.
Une politique de réessai est simple : lorsqu'une exception spécifique ou une faute se produit, Polly essaiera d'exécuter à nouveau le délégué sous-jacent. Vous pouvez définir combien de fois réessayer, l'intervalle de temps entre les réessais, ou utiliser une stratégie de décélération exponentielle sinon il réessayera indéfiniment. Voici un exemple :
// 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 politique de disjoncteur permet à la bibliothèque Polly de surveiller les fautes, et si le nombre de fautes dépasse un seuil configuré dans une période spécifiée, le circuit est "cassé", et d'autres requêtes sont bloquées pendant un temps spécifié. Cela s'appelle l'état 'ouvert'. Après ce temps, le circuit entre dans un état 'semi-ouvert', où il permet à un peu de trafic de vérifier la santé du service particulier. Si ces requêtes sont réussies et qu'aucune faute ne se produit, le circuit se referme; sinon, il s'ouvre à nouveau.
// 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))Les politiques de délai d'attente gèrent les scénarios où un service ne répond pas dans un délai raisonnable. Polly propose deux types de délais d'attente : Optimiste et Pessimiste. Un délai d'attente optimiste fonctionne sur un fil séparé et annule l'opération sous-jacente via un CancellationToken. Un délai d'attente pessimiste bloque le fil parent jusqu'à ce que l'opération se termine ou que la période de délai d'attente s'écoule.
// 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 secondsL'isolation par cloisonnement est utilisée pour limiter le nombre d'actions concurrentes contre un service particulier. Elle fournit un moyen d'isoler les fautes et d'empêcher qu'elles se propagent. Elle limite également la charge que nous imposons à nos dépendances.
// 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 slotsLes politiques de secours sont utiles lorsque vous devez fournir un comportement par défaut ou une valeur de substitution lorsque tout le reste échoue.
// 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)Plusieurs politiques peuvent être combinées de manière flexible en utilisant 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)Pour commencer à utiliser Polly avec IronPDF, assurez-vous d'avoir installé Visual Studio et de créer un nouveau projet d'application console dans .NET Core. Ouvrez la console du gestionnaire de packages NuGet dans Visual Studio et installez les packages Polly et IronPDF :
Une fonctionnalité importante d'IronPDF est sa capacité de conversion HTML en PDF, garantissant que les mises en page et les styles sont intacts. Cette fonction transforme le contenu web en PDF, ce qui est parfait pour les rapports, les factures et la documentation. Elle prend en charge la conversion de fichiers HTML, d'URL, et de chaînes HTML en 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 ClassPassons en revue un exemple d'utilisation de Polly avec IronPDF pour convertir une URL en PDF. Supposons que nous ayons un service web qui échoue occasionnellement en raison de fautes transitoires, et nous voulons gérer ces défaillances de manière élégante en utilisant Polly.
Tout d'abord, importons les espaces de noms nécessaires dans notre fichier 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 IronPdfEnsuite, nous définirons nos politiques. Dans cet exemple, nous utiliserons une combinaison de politiques de réessai et de disjoncteur pour gérer les échecs :
// 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))Le retryPolicy réessayera la demande échouée jusqu'à trois fois avec une stratégie de recouvrement exponentiel, en attendant 2 secondes, 4 secondes et 8 secondes entre les tentatives. Le circuitBreakerPolicy ouvrira le circuit si deux échecs consécutifs se produisent dans un intervalle de temps de 30 secondes.
Maintenant, définissons notre code IronPDF pour convertir une URL en 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")Dans le code exemple ci-dessus, nous enveloppons notre retryPolicy et circuitBreakerPolicy en utilisant la méthode WrapAsync. Cela nous permet d'appliquer plusieurs politiques aux nouvelles requêtes séquentiellement. La méthode ExecuteAsync exécute le délégué fourni, qui dans ce code est la méthode RenderUrlAsPdfAsync de IronPDF.
En appliquant les politiques de Polly, nous nous assurons que notre code est résilient aux fautes transitoires. Si une requête échoue, Polly la réessaiera automatiquement selon la politique de réessai. Si le nombre d'échecs consécutifs dépasse le seuil préconfiguré, la politique de disjoncteur ouvrira le circuit, empêchant d'autres requêtes pendant une durée spécifiée.
Pour tester l'efficacité de nos politiques Polly, simulons quelques requêtes échouées. Modifiez l'URL en un point de terminaison inexistant et ajoutez quelques cas de test :
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
NextDans le code ci-dessus, nous parcourons un ensemble d'URLs de test et tentons de convertir chacune d'elles en PDF. Si une requête échoue, l'exception sera capturée et un message approprié s'affichera dans la console.
Polly est une bibliothèque puissante et flexible pour implémenter la résilience et la gestion des fautes transitoires dans les applications .NET Core. En combinant des politiques de réessai et de disjoncteur, les développeurs peuvent construire des systèmes robustes et tolérants aux fautes qui gèrent les défaillances avec élégance.
Dans ce tutoriel, nous avons exploré comment utiliser Polly avec IronPDF pour convertir une URL en PDF. Nous avons appris à définir et appliquer les politiques Polly, y compris le réessai et le disjoncteur. Nous avons également testé nos politiques avec différentes URLs. Nous pouvons également le faire pour convertir du HTML en PDF.
IronPDF offre un essai gratuit, et les licences commencent à des prix compétitifs, vous permettant de tirer parti de ses capacités dans vos projets.
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.
