Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. Polly Retry
.NET AIDE

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

Curtis Chau
Curtis Chau
Mis à jour:

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 explorant 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.

Qu'est-ce que le réessai Polly ?

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.

Commencer avec Polly Retry

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

Installation de Polly

Vous pouvez installer Polly via la Console du Gestionnaire de Packages NuGet en utilisant la commande suivante :

Install-Package Polly

Ou via .NET CLI :

dotnet add package Polly

Ajouter des déclarations using de Polly

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

using Polly;
using Polly;
Imports Polly
$vbLabelText   $csharpLabel

Exemple de politique de réessai de base

Commenç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");
        }
    }
}
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 Namespace
$vbLabelText   $csharpLabel

Dans cet exemple :

  • Handle<HttpRequestException>() spécifie que nous voulons gérer les HttpRequestException et réessayer l'opération si elle se produit.
  • WaitAndRetry() 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 précisée).
  • Le délégué onRetry enregistre un message lorsqu'un réessai se produit.

Polly Retry (Comment cela fonctionne pour les développeurs) : Figure 1

Configuration de la politique de réessai avancée

Recule exponentiel

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 recul 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}");
        });
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)
$vbLabelText   $csharpLabel

Polly Retry (Comment cela fonctionne pour les développeurs) : Figure 2

Réessayer avec disjoncteur

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
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)
$vbLabelText   $csharpLabel

Dans cet exemple :

  • CircuitBreaker() définit une politique de disjoncteur qui se déclenche après 3 exceptions et reste ouvert pendant 30 secondes.
  • Policy.Wrap() combine les politiques de disjoncteur et de réessai en une seule politique.

Polly Retry (Comment cela fonctionne pour les développeurs) : Figure 3

Introduction à IronPDF

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 offre 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");
    }
}
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
$vbLabelText   $csharpLabel

Polly Retry avec IronPDF

Lorsque 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.

Installation de IronPDF et Polly

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

Install-Package IronPdf

Utilisation de Polly Retry avec IronPDF

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);
        }
    }
}
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 Namespace
$vbLabelText   $csharpLabel

Ce 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 en utilisant la méthode WaitAndRetryAsync de Polly.

Cette politique spécifie qu'elle doit gérer les 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.

Dans la méthode Main, la logique de politique de réessai est exécutée de manière asynchrone à l'aide de retryPolicy.ExecuteAsync(). Au sein de cette exécution, deux opérations asynchrones sont enchaînées : FetchDataFromExternalApiAsync() et GeneratePdfFromData(data).

Si FetchDataFromExternalApiAsync() échoue (car il est intentionnellement configuré pour le faire avec une exception simulée), la politique de réessai capturera l'HttpRequestException, enregistrera la tentative de réessai et réessaiera l'opération.

La méthode FetchDataFromExternalApiAsync() simule la récupération de données d'une API externe avec un délai et lance intentionnellement une HttpRequestException pour simuler des demandes échouées.

Polly Retry (Comment cela fonctionne pour les développeurs) : Figure 4

Conclusion

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 C# PDF sur le marché, elle offre également une licence d'essai pour IronPDF les prix commencent à partir de $799 USD.

Pour en savoir plus sur la conversion HTML en PDF avec IronPDF, visitez le tutoriel de conversion HTML en PDF IronPDF.

Questions Fréquemment Posées

Qu'est-ce que Polly Retry en C# ?

Polly Retry est une fonctionnalité de la bibliothèque Polly en C# qui permet aux développeurs de réessayer automatiquement des opérations qui échouent en raison de problèmes temporaires comme des perturbations réseau ou une indisponibilité de service. Cela aide à construire des applications résilientes en gérant les défaillances transitoires avec grâce.

Comment puis-je implémenter une politique de réessai basique en utilisant Polly ?

Vous pouvez implémenter une politique de réessai basique dans Polly en gérant des exceptions comme HttpRequestException et en la configurant pour réessayer un maximum de trois fois avec un délai fixe de deux secondes entre chaque tentative.

Quelle est la signification du backoff exponentiel dans Polly ?

Le backoff exponentiel dans Polly est utilisé pour augmenter le délai entre les réessais de manière exponentielle, ce qui aide à réduire la charge sur les services lors des échecs. Cela peut être implémenté en utilisant la méthode WaitAndRetry de Polly, qui calcule les délais basés sur une croissance exponentielle.

Comment installer Polly pour un projet C# ?

Vous pouvez installer Polly dans un projet C# en utilisant la console du gestionnaire de packages NuGet avec la commande Install-Package Polly ou via le CLI .NET avec dotnet add package Polly.

La politique de réessai de Polly peut-elle être combinée avec d'autres stratégies de résilience ?

Oui, Polly vous permet de combiner sa politique de réessai avec d'autres stratégies de résilience, comme un disjoncteur, en utilisant la méthode Policy.Wrap pour améliorer la résilience des applications et éviter des réessais répétés lorsqu'un service échoue constamment.

Comment puis-je convertir HTML en PDF en C# ?

Vous pouvez utiliser les méthodes d'IronPDF comme RenderHtmlAsPdf pour convertir des chaînes HTML en PDFs. IronPDF prend également en charge la conversion de fichiers HTML et de pages Web, y compris le CSS, au format PDF.

Pourquoi la politique de réessai de Polly est-elle importante pour les applications C# ?

La politique de réessai de Polly est cruciale pour gérer les défauts transitoires dans les applications C#, garantissant la robustesse et améliorant l'expérience utilisateur en permettant au système de se remettre de défaillances temporaires sans se planter.

Comment les stratégies de réessai peuvent-elles être mises en œuvre dans un processus de génération de PDF ?

Lors de la génération de PDFs, les stratégies de réessai peuvent être mises en œuvre en utilisant Polly pour gérer les défauts transitoires. En intégrant les capacités de réessai de Polly avec IronPDF, vous pouvez tenter des opérations PDF plusieurs fois en cas de problèmes temporaires de réseau ou de service.

Comment installer une bibliothèque PDF C# comme IronPDF ?

IronPDF peut être installé via le gestionnaire de packages NuGet avec la commande Install-Package IronPdf, vous permettant de créer, éditer et manipuler des documents PDF au sein de vos applications C#.

Quels sont les avantages d'utiliser IronPDF pour la génération de PDF ?

IronPDF offre des fonctionnalités puissantes pour créer et manipuler des documents PDF dans les applications .NET. Il prend en charge la conversion de HTML, CSS et pages Web en PDFs, l'ajout de texte et d'images, et la sécurisation des documents par cryptage.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit