Polly Retry (Comment ça marche pour les développeurs)

La gestion des erreurs transitoires, des dépassements de délai et des exceptions de manière gracieuse est cruciale pour la construction d'applications robustes et résilientes. Polly est une bibliothèque .NET populaire qui offre des capacités de résilience et de gestion des défaillances transitoires. Parmi ses nombreuses fonctionnalités, le "retry" est l'une des politiques les plus utilisées.

Dans cet article, nous allons nous pencher sur les points suivants Politique de relance de Polly en C#il s'agit d'un système de gestion de l'information, qui explore son utilisation et ses options de configuration, et qui fournit des exemples de code pratiques. Nous utiliserons également IronPDF avec la tentative de Polly Retry pour générer un PDF des résultats de la demande de formulaire.

Qu'est-ce que Polly Retry ?

Polly Retry est une politique fournie par la bibliothèque Polly qui permet aux développeurs de réessayer automatiquement les opérations qui pourraient échouer en raison d'une erreur ou de défauts transitoires. Les erreurs transitoires sont des erreurs temporaires qui se produisent en raison de problèmes de réseau, d'indisponibilité du service ou d'autres problèmes transitoires.

Avec la politique de réessai de Polly, vous pouvez définir des règles pour les opérations de réessai, y compris le nombre maximum de réessais, le délai entre plusieurs réessais et les conditions de réessai d'une demande qui a échoué. Cela permet de construire des applications résilientes qui peuvent se remettre de défaillances temporaires sans tomber en panne ou provoquer des interruptions pour les utilisateurs finaux.

Démarrer avec Polly Retry

Avant de nous plonger dans les exemples de code, nous allons comprendre comment installer et configurer Polly dans un projet C#.

Installation de Polly

Vous pouvez installer Polly via la console NuGet Package Manager en utilisant la commande suivante :

Install-Package Polly

Install-Package Polly

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'Install-Package Polly

Ou via l'interface de programmation .NET :

dotnet add package Polly

dotnet add package Polly

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'dotnet add package Polly

Ajout de Polly à l'aide de déclarations

Dans votre fichier C#, incluez l'espace de noms Polly :

using Polly;

using Polly;

Imports Polly

Exemple de politique de rappel de base

Commençons par un exemple simple dans lequel nous essayons à nouveau une opération qui simule la récupération de données à partir 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 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)
        {
           var retryPolicy = Policy
                .Handle<HttpRequestException>()
                .WaitAndRetry(
                    3,
                    retryAttempt => TimeSpan.FromSeconds(2),
                    (exception, timeSpan, retryCount, context) =>
                    {
                        Console.WriteLine("Retry {0} due to {1}", retryCount, exception.Message);
                    });
            try
            {
                retryPolicy.Execute(() =>
                {
                    FetchDataFromRemoteService();
                });
            }
            catch (Exception ex)
            {
                Console.WriteLine("Failed after 3 retries: {0}", ex.Message);
            }
        }
        public static void FetchDataFromRemoteService()
        {
            throw new HttpRequestException("Failed to fetch data from remote service");
        }
    }
}

using System;
using System.Net.Http;
using Polly;
namespace PollyRetryExample
{
    public class Program
    {
        public static void Main(string[] args)
        {
           var retryPolicy = Policy
                .Handle<HttpRequestException>()
                .WaitAndRetry(
                    3,
                    retryAttempt => TimeSpan.FromSeconds(2),
                    (exception, timeSpan, retryCount, context) =>
                    {
                        Console.WriteLine("Retry {0} due to {1}", retryCount, exception.Message);
                    });
            try
            {
                retryPolicy.Execute(() =>
                {
                    FetchDataFromRemoteService();
                });
            }
            catch (Exception ex)
            {
                Console.WriteLine("Failed after 3 retries: {0}", ex.Message);
            }
        }
        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)
		   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
				retryPolicy.Execute(Sub()
					FetchDataFromRemoteService()
				End Sub)
			Catch ex As Exception
				Console.WriteLine("Failed after 3 retries: {0}", ex.Message)
			End Try
		End Sub
		Public Shared Sub FetchDataFromRemoteService()
			Throw New HttpRequestException("Failed to fetch data from remote service")
		End Sub
	End Class
End Namespace

Dans cet exemple :

• Handle<HttpRequestException>() spécifie que nous voulons gérer la HttpRequestException et réessayer l'opération si elle se produit.
• AttenteetRépétition() configure la politique de réessai avec 3 réessais et un délai fixe de 2 secondes entre les réessais (durée maximale spécifiée).

• le délégué onRetry enregistre un message lorsqu'une nouvelle tentative a lieu.

  

Configuration avancée de la politique de rappel

Retard exponentiel

Le backoffing exponentiel est une stratégie de relance populaire dans laquelle le délai entre les demandes et les relances augmente de manière exponentielle. Polly fournit un moyen pratique d'implémenter un backoff exponentiel en utilisant WaitAndRetry().

var retryPolicy = Policy
    .Handle<HttpRequestException>()
    .WaitAndRetry(
        retryCount: 3,
        sleepDurationProvider: attempt => TimeSpan.FromSeconds(Math.Pow(2, attempt)),
        onRetry: (exception, retryCount, context) =>
        {
            Console.WriteLine($"Retry {retryCount} due to {exception.Message}");
        });

var retryPolicy = Policy
    .Handle<HttpRequestException>()
    .WaitAndRetry(
        retryCount: 3,
        sleepDurationProvider: attempt => TimeSpan.FromSeconds(Math.Pow(2, attempt)),
        onRetry: (exception, 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, retryCount, context)
	Console.WriteLine($"Retry {retryCount} due to {exception.Message}")
End Sub)

Réessayer avec le disjoncteur

La combinaison de la relance avec un disjoncteur peut encore améliorer la résilience en empêchant les relances répétées lorsqu'un service est constamment défaillant. Polly vous permet de combiner facilement les politiques de réessai et de disjoncteur.

var circuitBreakerPolicy = Policy
    .Handle<HttpRequestException>()
    .CircuitBreaker(
        exceptionsAllowedBeforeBreaking: 3,
        durationOfBreak: TimeSpan.FromSeconds(30),
        onBreak: (ex, breakDelay) =>
        {
            Console.WriteLine($"Circuit broken due to {ex.Message}. Retry after {breakDelay.TotalSeconds} seconds.");
        },
        onReset: () =>
        {
            Console.WriteLine("Circuit reset.");
        });
var retryPolicy = Policy
    .Handle<HttpRequestException>()
    .WaitAndRetry(
        retryCount: 3,
        sleepDurationProvider: attempt => TimeSpan.FromSeconds(2),
        onRetry: (exception, retryCount, context) =>
        {
            Console.WriteLine($"Retry {retryCount} due to {exception.Message}");
        });
var policyWrap = Policy.Wrap(circuitBreakerPolicy, retryPolicy);

var circuitBreakerPolicy = Policy
    .Handle<HttpRequestException>()
    .CircuitBreaker(
        exceptionsAllowedBeforeBreaking: 3,
        durationOfBreak: TimeSpan.FromSeconds(30),
        onBreak: (ex, breakDelay) =>
        {
            Console.WriteLine($"Circuit broken due to {ex.Message}. Retry after {breakDelay.TotalSeconds} seconds.");
        },
        onReset: () =>
        {
            Console.WriteLine("Circuit reset.");
        });
var retryPolicy = Policy
    .Handle<HttpRequestException>()
    .WaitAndRetry(
        retryCount: 3,
        sleepDurationProvider: attempt => TimeSpan.FromSeconds(2),
        onRetry: (exception, retryCount, context) =>
        {
            Console.WriteLine($"Retry {retryCount} due to {exception.Message}");
        });
var policyWrap = Policy.Wrap(circuitBreakerPolicy, retryPolicy);

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)
Dim retryPolicy = Policy.Handle(Of HttpRequestException)().WaitAndRetry(retryCount:= 3, sleepDurationProvider:= Function(attempt) TimeSpan.FromSeconds(2), onRetry:= Sub(exception, retryCount, context)
	Console.WriteLine($"Retry {retryCount} due to {exception.Message}")
End Sub)
Dim policyWrap = Policy.Wrap(circuitBreakerPolicy, retryPolicy)

Dans cet exemple :

• CircuitBreaker() définit une politique en matière de disjoncteur qui se déclenche après 3 exceptions et reste ouvert pendant 30 secondes.

• Policy.Wrap() combine les politiques de coupe-circuit et de réessai en une seule politique.

  

Introduction à IronPDF

IronPDF pour C# est une puissante bibliothèque C# qui permet aux développeurs de créer, d'éditer et de 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 propose une API intuitive qui simplifie le processus.

Avec IronPDF, vous pouvez facilement convertir des pages web HTML, CSS et même ASP.NET en PDF, ce qui en fait un outil polyvalent pour un grand nombre d'applications. En outre, il offre des fonctionnalités avancées telles que l'ajout de texte, d'images et d'éléments interactifs aux PDF, ainsi que la sécurisation de ces derniers par le chiffrement et les signatures numériques.

Polly Retry avec IronPDF

Lorsque vous travaillez avec IronPDF, il peut arriver que vous ayez besoin d'extraire des données de sources externes ou d'effectuer des opérations complexes avant de générer un PDF.

Dans de tels cas, vous pouvez rencontrer des défauts transitoires ou des problèmes temporaires qui peuvent entraîner des échecs de génération de PDF. Pour traiter ces erreurs transitoires avec élégance, vous pouvez utiliser Polly Retry en conjonction avec IronPDF.

Installation d'IronPDF et de Polly

Avant de commencer, assurez-vous d'installer le paquetage NuGet IronPDF dans votre projet.

Install-Package IronPdf

Utilisation de Polly Retry avec IronPDF

Examinons un exemple dans lequel nous utilisons Polly Retry pour gérer les erreurs transitoires lors de la génération d'un PDF à l'aide d'IronPDF. Dans l'exemple suivant, nous simulerons la récupération de données à partir d'une API externe, puis la génération d'un PDF sur la base de ces données. Nous utiliserons Polly Retry pour exécuter l'opération de récupération des données en cas d'échec.

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)
        {
            var retryPolicy = Policy
                .Handle<HttpRequestException>()
                .WaitAndRetryAsync(
                    3,//retry attempts
                    retryAttempt => TimeSpan.FromSeconds(2),//calculated retry delay
                    (exception, timeSpan, retryCount, context) =>
                    {
                        Console.WriteLine("Retry " + retryCount + " due to " + exception.Message);
                    });
            var pdf = await retryPolicy.ExecuteAsync(async () =>
            {
                var data = await FetchDataFromExternalApiAsync();
                return GeneratePdfFromData(data);
            });
            pdf.SaveAs("GeneratedDocument.pdf");
        }
        static async Task<string> FetchDataFromExternalApiAsync()
        {
            // Simulate fetching data from an external API
            await Task.Delay(100); // Simulate delay
            throw new HttpRequestException("Failed to fetch data from external API");
        }
        static PdfDocument GeneratePdfFromData(string data)
        {
            // Generate PDF using IronPDF based on the fetched data
            var htmlContent = "<html><body><h1>Data: " + data + "</h1></body></html>";
            var renderer = new ChromePdfRenderer();
            return renderer.RenderHtmlAsPdf(htmlContent);
        }
    }
}

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)
        {
            var retryPolicy = Policy
                .Handle<HttpRequestException>()
                .WaitAndRetryAsync(
                    3,//retry attempts
                    retryAttempt => TimeSpan.FromSeconds(2),//calculated retry delay
                    (exception, timeSpan, retryCount, context) =>
                    {
                        Console.WriteLine("Retry " + retryCount + " due to " + exception.Message);
                    });
            var pdf = await retryPolicy.ExecuteAsync(async () =>
            {
                var data = await FetchDataFromExternalApiAsync();
                return GeneratePdfFromData(data);
            });
            pdf.SaveAs("GeneratedDocument.pdf");
        }
        static async Task<string> FetchDataFromExternalApiAsync()
        {
            // Simulate fetching data from an external API
            await Task.Delay(100); // Simulate delay
            throw new HttpRequestException("Failed to fetch data from external API");
        }
        static PdfDocument GeneratePdfFromData(string data)
        {
            // Generate PDF using IronPDF based on the fetched 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
			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)
			Dim pdf = Await retryPolicy.ExecuteAsync(Async Function()
				Dim data = Await FetchDataFromExternalApiAsync()
				Return GeneratePdfFromData(data)
			End Function)
			pdf.SaveAs("GeneratedDocument.pdf")
		End Function
		Private Shared Async Function FetchDataFromExternalApiAsync() As Task(Of String)
			' Simulate fetching data from an external API
			Await Task.Delay(100) ' Simulate delay
			Throw New HttpRequestException("Failed to fetch data from external API")
		End Function
		Private Shared Function GeneratePdfFromData(ByVal data As String) As PdfDocument
			' Generate PDF using IronPDF based on the fetched data
			Dim htmlContent = "<html><body><h1>Data: " & data & "</h1></body></html>"
			Dim renderer = New ChromePdfRenderer()
			Return renderer.RenderHtmlAsPdf(htmlContent)
		End Function
	End Class
End Namespace

Ce code C# montre comment utiliser la bibliothèque Polly pour mettre en œuvre des politiques de relance avec IronPDF pour générer un document PDF. La méthode Main initialise une politique de relance en 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 première tentative et les réessais. En cas d'échec de la tentative, un message est imprimé sur la console, indiquant le numéro de la tentative et le message d'exception.

Dans la méthode Main, la logique de la politique de relance est exécutée de manière asynchrone en utilisant retryPolicy.ExecuteAsync(). Dans cette exécution, deux opérations asynchrones sont enchaînées :FetchDataFromExternalApiAsync()etGeneratePdfFromData(données)`.

Si FetchDataFromExternalApiAsync() échoue (comme il est intentionnellement conçu pour le faire avec une exception simulée)la politique de réessai va capturer la HttpRequestException, enregistrer la tentative de réessai, et réessayer l'opération.

La fonction FetchDataFromExternalApiAsync()la méthode simule la récupération de données d'une API externe avec un délai et lance intentionnellement une HttpRequestException pour simuler l'échec des requêtes.

Conclusion

En conclusion, la politique de relance de Polly s'avère inestimable pour gérer les erreurs transitoires et garantir 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.

Qu'ils soient utilisés indépendamment ou en conjonction avec des bibliothèques telles que IronPDFpolly facilite la création d'applications qui se remettent gracieusement des défaillances temporaires, améliorant ainsi l'expérience de l'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, capables de s'adapter et de récupérer des problèmes transitoires, améliorant ainsi la qualité et la fiabilité globales de leurs applications.

IronPDF est la meilleure bibliothèque PDF C# du marché, elle offre également une licence d'essai les prix commencent à partir de $749 USD.

Pour en savoir plus sur la conversion de HTML en PDF à l'aide d'IronPDF, consultez le site suivant lien.