AIDE .NET

.NET Core Polly (Comment ça marche pour les développeurs)

Kannapat Udonpant

juillet 26, 2023

Polly est une bibliothèque .NET de stratégies de résilience et de gestion des défaillances transitoires, permettant aux développeurs d'exprimer des politiques de résilience telles que la politique de réessai, les disjoncteurs, le délai d'attente, la politique d'isolation des cloisons et le repli. 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 permet de traiter plusieurs requêtes simultanées avec des réponses positives.

Ce tutoriel fournira plus de détails sur la bibliothèque .NET de traitement des défauts transitoires, Polly, et sur la manière de l'utiliser avecIronPDF dans une application ASP.NET Core. Nous allons plonger en profondeur dans chaque aspect de Polly, expliquer les mécanismes du modèle de disjoncteur, discuter de l'isolation des cloisons et des délais d'attente, et montrer comment gérer des exceptions spécifiques ou un service défaillant avec des réponses d'échec d'une manière contrôlée et sûre pour les threads.

Politiques de Polly

Les erreurs transitoires se produisent souvent lorsque votre application tente de se connecter à un service web via une requête HTTP, à une base de données ou à d'autres ressources externes. Ces défaillances, telles que les pannes de réseau, les problèmes temporaires de connectivité ou les dépassements de délai, sont brèves et se corrigent généralement d'elles-mêmes après un court laps de temps.

Polly gère ces défauts transitoires en appliquant différentes stratégies et en exprimant des politiques telles que la politique de réessai, la politique de disjoncteur avancé, la politique de temporisation, la politique de repli et la politique d'isolation de la tête de pont.

Politique de réessai

La politique de relance relance automatiquement les demandes concurrentes qui ont échoué en utilisant la logique de relance. Il peut être configuré pour effectuer des tentatives permanentes ou des tentatives automatiques pendant un certain nombre de fois, et il peut attendre un intervalle de temps défini entre les tentatives ou utiliser un délai exponentiel.

Disjoncteur

La politique Circuit Breaker permet à votre système de prendre en charge un jeton d'annulation pour l'essai d'un service particulier après un seuil préconfiguré de demandes infructueuses. La stratégie du coupe-circuit est analogue à l'ingénierie du chaos ou à la fermeture des portes étanches d'un navire pour localiser les dégâts : une seule défaillance ne fera pas couler tout le navire.

Politique de temporisation

La politique de délai d'attente fixe la durée maximale d'exécution d'un élément particulier du code de résilience .NET. Il existe deux types de délais : le délai optimiste et le délai pessimiste.

Politique de repli

La politique de repli est utilisée pour fournir une valeur ou un comportement de remplacement en cas de défaillance. Cette politique peut être utile lorsqu'un service défaillant ne doit pas interrompre l'ensemble du processus.

Isolation des cloisons

L'isolation Bulkhead est utilisée pour limiter le nombre de requêtes simultanées qui peuvent être faites à 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.

Politique de cache

La politique de cache met en cache la réponse réussie d'une exécution de sorte que si la même exécution est invoquée à nouveau, Polly peut renvoyer la valeur du cache distribué.

Enveloppe de la politique

Il nous permet de regrouper plusieurs politiques afin qu'elles fonctionnent comme une seule unité.

Créer et configurer des politiques

Politique de réessai

Une politique de réessai est simple : lorsqu'une exception spécifique ou une erreur se produit, Polly essaie d'exécuter à nouveau le délégué sous-jacent. Vous pouvez définir le nombre de tentatives, l'intervalle de temps entre les tentatives ou utiliser une stratégie de recul exponentiel, faute de quoi la tentative sera permanente. En voici un exemple :

//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)

Politique en matière de disjoncteur

La politique du coupe-circuit permet à la bibliothèque Polly de surveiller les erreurs, et si le nombre d'erreurs dépasse un seuil configuré au cours d'une période donnée, le circuit est "rompu" et les demandes ultérieures sont bloquées pendant une période donnée. C'est ce qu'on appelle l'état "ouvert". Après ce délai, le circuit entre dans un état "semi-ouvert", où il autorise un certain trafic pour vérifier l'état de santé du service en question. Si ces demandes aboutissent et qu'aucune erreur ne se produit, le circuit se ferme ; sinon, il s'ouvre à nouveau.

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))

Politique de temporisation

Les règles de temporisation permettent de gérer les scénarios dans lesquels un service ne répond pas dans un délai raisonnable. Polly propose deux types de délais : Optimiste et Pessimiste. Un timeout optimiste fonctionne sur un thread séparé et annule l'opération sous-jacente via un CancellationToken. Un délai pessimiste bloque le thread parent jusqu'à ce que l'opération soit terminée ou que le délai soit écoulé.

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

Isolation des cloisons

L'isolation des cloisons est utilisée pour limiter le nombre d'actions simultanées sur un service particulier. Il permet d'isoler les fautes et d'éviter qu'elles ne se reproduisent en cascade. Il limite également la charge que nous faisons peser sur nos dépendances.

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

Politique de repli

Les politiques de repli sont utiles lorsque vous devez fournir un comportement par défaut ou une valeur de remplacement en cas d'échec.

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)

Envelopper les politiques

Plusieurs politiques peuvent être combinées de manière flexible à l'aide d'une 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

Pour commencer

Pour commencer à utiliser Polly avec IronPDF, assurez-vous que Visual Studio est installé et créez un nouveau projet d'application console dans .NET Core. Ouvrez la console NuGet Package Manager dans Visual Studio et installez les paquets Polly et IronPdf :

Install-Package Polly

:ProductInstall Install-Package IronPdf

Utilisation de Polly avec IronPDF Conversion d'une URL en PDF

L'une des principales caractéristiques d'IronPDF est sonCapacité de conversion de HTML en PDFla traduction doit également respecter l'intégrité des mises en page et des styles. Cette fonction transforme le contenu web en PDF, ce qui est parfait pour les rapports, les factures et la documentation. Il permet de convertir des fichiers HTML, des URL et des 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");
    }
}

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

Voyons un exemple d'utilisation de Polly avec IronPDF pourconvertir une URL en PDF. Supposons que nous ayons un service web qui tombe occasionnellement en panne à cause d'erreurs transitoires, et que nous voulions gérer ces pannes 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;

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

Ensuite, nous définirons nos politiques. Dans cet exemple, nous utiliserons une combinaison de politiques de réessai et de disjoncteur pour gérer les défaillances :

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 politique retryPolicy réessaie la requête échouée jusqu'à trois fois avec une stratégie de backoff exponentielle, en attendant 2 secondes, 4 secondes et 8 secondes entre les réessais. La circuitBreakerPolicy ouvrira le circuit si deux défaillances consécutives se produisent dans un intervalle de temps de 30 secondes.

Définissons maintenant notre code IronPDF pour convertir une URL en 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")

Dans l'exemple de code ci-dessus, nous enveloppons nos retryPolicy et circuitBreakerPolicy en utilisant la méthode WrapAsync. Cela nous permet d'appliquer plusieurs politiques aux nouvelles demandes de manière séquentielle. La méthode ExecuteAsync exécute le délégué fourni, qui dans ce code est la méthode RenderUrlAsPdfAsync d'IronPDF.

En appliquant les politiques Polly, nous nous assurons que notre code est résistant aux fautes transitoires. Si une demande échoue, Polly la relance automatiquement conformément à la politique de relance. Si le nombre d'échecs consécutifs dépasse le seuil préconfiguré, la politique du coupe-circuit ouvre le circuit, empêchant toute nouvelle demande pendant une durée déterminée.

Cas de test pour les politiques Polly

Pour tester l'efficacité de nos politiques Polly, simulons des demandes qui échouent. Modifiez l'URL vers 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}");
    }
}

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

Dans le code ci-dessus, nous itérons sur un ensemble d'URL de test et tentons de convertir chacun d'entre eux en PDF. Si une demande échoue, l'exception est prise en compte et un message approprié est affiché dans la console.

.NET Core Polly(Comment ça marche pour les développeurs) : Figure 1 - Sortie de l'URL en PDF

Conclusion

Polly est une bibliothèque puissante et flexible pour mettre en œuvre la résilience et la gestion des fautes transitoires dans les applications .NET Core. En combinant des politiques telles que le retry et le circuit breaker, les développeurs peuvent construire des systèmes robustes et tolérants aux pannes 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 la réessai et le coupe-circuit. Nous avons également testé nos politiques avec différentes URL. Nous pouvons également le faire pourconvertir HTML en PDF.

IronPDF offre un service deessai gratuitles prix de la traduction, de l'utilisation et des licences sont compétitifs, ce qui vous permet d'exploiter les capacités de ces outils dans vos projets.

Kannapat Udonpant

Discutez avec l'équipe d'ingénierie maintenant

Ingénieur logiciel

Avant de devenir ingénieur logiciel, Kannapat a obtenu un doctorat en ressources environnementales à l'université d'Hokkaido au Japon. Tout en poursuivant ses études, Kannapat est également devenu membre du Vehicle Robotics Laboratory, qui fait partie du Department of Bioproduction Engineering (département d'ingénierie de la bioproduction). En 2022, il a mis à profit ses compétences en C# pour rejoindre l'équipe d'ingénieurs d'Iron Software, où il se concentre sur IronPDF. Kannapat apprécie son travail car il apprend directement auprès du développeur qui écrit la majeure partie du code utilisé dans IronPDF. Outre l'apprentissage par les pairs, Kannapat apprécie l'aspect social du travail chez Iron Software. Lorsqu'il n'écrit pas de code ou de documentation, Kannapat peut généralement être trouvé en train de jouer sur sa PS5 ou de revoir The Last of Us.

< PRÉCÉDENT
C# Split String (Comment ça marche pour les développeurs)

SUIVANT >
Blazor vs MVC (Comment ça marche pour les développeurs)