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

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

Curtis Chau
Curtis Chau
Mis à jour:

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.

Politiques Polly

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.

Politique de réessai

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.

Disjoncteur

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.

Politique de délai d'attente

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.

Politique de secours

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.

Isolation du cloisonnement

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.

Politique de cache

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

Enveloppement de politiques

Permet de regrouper plusieurs politiques ensemble, afin qu'elles puissent fonctionner comme une unité unique.

Créer et configurer des politiques

Politique de réessai

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

Disjoncteur Policy

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

Politique de délai d'attente

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
var timeoutPolicy = Policy.TimeoutAsync(30); // 30 seconds
' Timeout policy with a 30-second optimistic timeout
Dim timeoutPolicy = Policy.TimeoutAsync(30) ' 30 seconds
$vbLabelText   $csharpLabel

Isolation du cloisonnement

L'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
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 slots
$vbLabelText   $csharpLabel

Politique de secours

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

Enveloppement des politiques

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
var policyWrap = Policy.WrapAsync(fallbackPolicy, retryPolicy, circuitBreakerPolicy, timeoutPolicy, bulkheadIsolationPolicy);
' Combining multiple policies using PolicyWrap
Dim policyWrap = Policy.WrapAsync(fallbackPolicy, retryPolicy, circuitBreakerPolicy, timeoutPolicy, bulkheadIsolationPolicy)
$vbLabelText   $csharpLabel

Démarrage

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 paquets NuGet dans Visual Studio et installez les packages Polly et IronPDF :

Install-Package Polly
Install-Package IronPdf

Utiliser Polly avec IronPDF pour convertir une URL en PDF

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");
    }
}
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

Passons 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;
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
$vbLabelText   $csharpLabel

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

La retryPolicy réessaiera la requête échouée jusqu'à trois fois avec une stratégie de décélération exponentielle, en attendant 2 secondes, 4 secondes, et 8 secondes entre les réessais. La 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");
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")
$vbLabelText   $csharpLabel

Dans l'exemple de code ci-dessus, nous enveloppons notre retryPolicy et notre 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 d'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.

Cas de test pour les politiques Polly

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

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

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

Conclusion

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.

Questions Fréquemment Posées

Qu'est-ce que Polly et comment améliore-t-il la résilience de .NET Core ?

Polly est une bibliothèque .NET conçue pour la résilience et la gestion des fautes transitoires, notamment pour les applications ASP.NET Core. Il améliore la résilience en fournissant des stratégies telles que Retry, Circuit Breakers, Timeout, Bulkhead Isolation et Fallback, assurant des systèmes robustes et tolérants aux pannes.

Comment puis-je utiliser Polly pour implémenter une politique de Retry dans .NET Core ?

Dans .NET Core, vous pouvez utiliser Polly pour implémenter une politique de Retry en le configurant pour relancer automatiquement les requêtes échouées. Cela peut être fait en définissant le nombre de retries et l'intervalle de temps entre les tentatives, permettant une gestion efficace des fautes transitoires.

Comment la politique Circuit Breaker prévient-elle les échecs en cascade dans les applications .NET ?

La politique Circuit Breaker dans Polly prévient les échecs en cascade en surveillant les pannes et en ouvrant le circuit pour bloquer les requêtes lorsqu'un seuil de pannes est atteint. Cela arrête les requêtes supplémentaires jusqu'à ce que le circuit se réinitialise, permettant au système de se rétablir avant d'accepter de nouvelles requêtes.

Quel rôle joue la Bulkhead Isolation dans la gestion de l'épuisement des ressources ?

La Bulkhead Isolation dans Polly limite le nombre de requêtes simultanées à un service, prévenant l'épuisement des ressources en contrôlant les emplacements d'exécution. Cette politique aide à contenir les échecs et assure une gestion efficace des ressources au sein d'une application .NET Core.

Comment la politique de Timeout de Polly peut-elle améliorer la réactivité de mon application ?

La politique de Timeout de Polly impose un temps d'exécution maximal pour les opérations, ce qui aide à gérer les scénarios où les services ne répondent pas rapidement. En établissant des timeouts optimistes ou pessimistes, les développeurs peuvent s'assurer que leurs applications demeurent réactives.

Polly peut-il être utilisé pour améliorer la fiabilité de la conversion d'URL en PDF ?

Oui, Polly peut améliorer la fiabilité de la conversion d'URL en PDF en intégrant ses politiques de Retry et Circuit Breaker avec les outils de génération de PDF. Cela garantit que les processus de conversion sont résilients aux fautes transitoires, maintenant la fiabilité.

Les stratégies de dépannage courantes comprennent la vérification des configurations, comme les intervalles de retry et les seuils de circuit breaker, ainsi que le test des politiques dans divers scénarios pour s'assurer de la bonne gestion des fautes.

Une politique de Fallback dans Polly fournit des réponses ou des comportements alternatifs lorsqu'un service échoue. Cela aide à garantir qu'une panne n'interrompt pas l'ensemble de l'application, permettant une dégradation gracieuse et une opération continue.

Comment combinez-vous plusieurs politiques Polly dans une application .NET ?

Dans une application .NET, plusieurs politiques Polly peuvent être combinées à l'aide de Policy Wraps. Cela permet aux développeurs d'exécuter différentes stratégies de résilience ensemble, permettant une approche de gestion des fautes plus complète et flexible.

Comment l'intégration de Polly avec IronPDF gère-t-elle les fautes transitoires lors de la génération de PDF ?

En intégrant Polly avec IronPDF, les développeurs peuvent gérer les fautes transitoires lors de la génération de PDF grâce à des politiques comme le retry et le circuit breaker. Cette intégration assure une génération de PDF stable et fiable malgré les interruptions de service occasionnelles.

Quelles sont quelques stratégies de dépannage courantes lors de l'utilisation de Polly avec .NET Core ?

Les stratégies de dépannage courantes incluent la vérification des configurations de politique, telles que les intervalles de retry et les seuils de circuit breaker, et le test des politiques avec différents scénarios pour s'assurer de la bonne gestion des fautes et de la résilience du système.

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