Polly Retry (Funktionsweise für Entwickler)

Installation von Polly

Sie können Polly über die NuGet-Package-Manager-Konsole mit dem folgenden Befehl installieren:

Install-Package Polly

Oder über die .NET CLI:

dotnet add package Polly

Hinzufügen von Polly using statements

Fügen Sie in Ihrer C#-Datei den Polly-Namespace ein:

using Polly;

using Polly;

Imports Polly

Exponentialer Backoff

Exponentielles Backoff ist eine beliebte Retriermethode, bei der sich die Verzögerung zwischen Anfragen und Wiederholungen exponentiell erhöht. Polly bietet eine bequeme Möglichkeit, exponentielles Backoff mit WaitAndRetry() zu implementieren.

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)

Rhetorik mit Circuit Breaker

Das Kombinieren von Retrierichtlinie mit einem Circuit Breaker verbessert die Resilienz, indem wiederholte Versuche bei Dienstfehlern verhindert werden. Polly ermöglicht es Ihnen, Retrierichtlinien und Circuit Breaker-Richtlinien einfach zu kombinieren.

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

In diesem Beispiel:

• CircuitBreaker() definiert eine Schutzschalterrichtlinie, die nach 3 Ausnahmen auslöst und 30 Sekunden lang offen bleibt.
• Policy.Wrap() kombiniert die Circuit-Breaker- und Retry-Richtlinien zu einer einzigen Richtlinie.

Polly Retry mit IronPDF

Bei der Arbeit mit IronPDF kann es Szenarien geben, in denen Sie Daten aus externen Quellen abrufen oder komplexe Operationen durchführen müssen, bevor Sie ein PDF erstellen.

In solchen Fällen können vorübergehende Fehler oder temporäre Probleme auftreten, die zu PDF-Erstellungsausfällen führen könnten. Um diese vorübergehenden Fehler elegant zu behandeln, können Sie Polly Retry in Verbindung mit IronPDF verwenden.

Installation von IronPDF und Polly

Bevor Sie beginnen, stellen Sie sicher, dass Sie das IronPDF NuGet-Paket in Ihr Projekt installieren.

Install-Package IronPdf

Verwendung von Polly Retry mit IronPDF

Lassen Sie uns ein Beispiel betrachten, in dem wir Polly Retry verwenden, um vorübergehende Fehler zu behandeln, wenn ein PDF mit IronPDF erstellt wird. Im folgenden Beispiel simulieren wir das Abrufen von Daten von einer externen API und dann die Erstellung eines PDFs basierend auf diesen Daten. Wir werden Polly Retry verwenden, um die Datenabrufoperation im Fehlerfall auszuführen.

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

Dieser C#-Code zeigt, wie die Polly-Bibliothek zur Implementierung von Retrierichtlinien mit IronPDF zur Erstellung eines PDF-Dokuments verwendet wird. Die Methode Main initialisiert eine Wiederholungsrichtlinie mithilfe der Methode WaitAndRetryAsync von Polly.

Diese Richtlinie legt fest, dass sie HttpRequestException behandeln und den Vorgang bis zu 3 Mal mit einer Verzögerung von 2 Sekunden zwischen dem ersten Versuch und den Wiederholungsversuchen wiederholen soll. Wenn ein Wiederholungsfehler auftritt, wird eine Nachricht in der Konsole ausgegeben, die die Anzahl der Wiederholungsversuche und die Ausnahmemeldung angibt.

Innerhalb der Methode Main wird die Wiederholungslogik asynchron mit retryPolicy.ExecuteAsync() ausgeführt. Innerhalb dieser Ausführung werden zwei asynchrone Operationen miteinander verkettet: FetchDataFromExternalApiAsync() und GeneratePdfFromData(data).

Falls FetchDataFromExternalApiAsync() fehlschlägt (was aufgrund einer simulierten Ausnahme beabsichtigt ist), fängt die Wiederholungsrichtlinie den Fehler HttpRequestException ab, protokolliert den Wiederholungsversuch und versucht die Operation erneut.

Die Methode FetchDataFromExternalApiAsync() simuliert das Abrufen von Daten von einer externen API mit einer Verzögerung und löst absichtlich einen HttpRequestException aus, um fehlgeschlagene Anfragen zu simulieren.