Polly Retry (Wie es für Entwickler funktioniert)

Die ordnungsgemäße Behandlung von vorübergehenden Fehlern, Zeitüberschreitungen und Ausnahmen ist entscheidend für die Entwicklung robuster und widerstandsfähiger Anwendungen. Polly ist eine weit verbreitete .NET-Bibliothek, die Ausfallsicherheit und Funktionen zur Behandlung transienter Fehler bietet. Unter den zahlreichen Funktionen ist "Wiederholung" eine der am häufigsten verwendeten Maßnahmen.

In diesem Artikel befassen wir uns mit Polly's Wiederholungsrichtlinie in C#, wobei die Verwendung und die Konfigurationsoptionen untersucht und praktische Codebeispiele gegeben werden. Außerdem werden wir IronPDF mit dem Polly-Retry-Versuch, eine PDF-Datei mit den Ergebnissen der Formularanfrage zu erstellen.

Was ist Polly Retry?

Polly Retry ist eine von der Polly-Bibliothek bereitgestellte Richtlinie, die es Entwicklern ermöglicht, Operationen, die aufgrund eines Fehlers oder vorübergehender Störungen fehlschlagen könnten, automatisch zu wiederholen. Vorübergehende Fehler sind vorübergehende Fehler, die aufgrund von Netzwerkstörungen, Nichtverfügbarkeit von Diensten oder anderen vorübergehenden Problemen auftreten.

Mit der Wiederholungsrichtlinie von Polly können Sie Regeln für die Wiederholung von Vorgängen definieren, einschließlich der maximalen Anzahl von Wiederholungen, der Verzögerung zwischen mehreren Wiederholungen und der Bedingungen für die Wiederholung einer fehlgeschlagenen Anfrage. Dies hilft bei der Entwicklung von robusten Anwendungen, die sich von vorübergehenden Fehlern erholen können, ohne abzustürzen oder Unterbrechungen für die Endbenutzer zu verursachen.

Erste Schritte mit Polly Retry

Bevor wir uns den Code-Beispielen zuwenden, sollten wir ein grundlegendes Verständnis dafür entwickeln, wie man Polly in einem C#-Projekt installiert und konfiguriert.

Installation von Polly

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

Install-Package Polly

Install-Package Polly

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

Oder über .NET CLI:

dotnet add package Polly

dotnet add package Polly

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

Hinzufügen von Polly mittels Anweisungen

Schließen Sie in Ihrer C#-Datei den Polly-Namensraum ein:

using Polly;

using Polly;

Imports Polly

Beispiel für eine grundlegende Wiederholungsrichtlinie

Beginnen wir mit einem einfachen Beispiel, bei dem wir einen Vorgang wiederholen, der das Abrufen von Daten von einem Remote-Dienst simuliert. Wir werden eine Wiederholungsrichtlinie mit maximal 3 Wiederholungen und einer festen Timeout-Verzögerung von 2 Sekunden zwischen den Wiederholungen einrichten.

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

In diesem Beispiel:

• `Handle()gibt an, dass wir eine "HttpRequestException" behandeln und den Vorgang wiederholen wollen, wenn sie auftritt.
• abwarten und Abwarten()` konfiguriert die Wiederholungsrichtlinie mit 3 Wiederholungen und einer festen Verzögerung von 2 Sekunden zwischen den Wiederholungen (angegebene Höchstdauer).

• der Delegat "onRetry" protokolliert eine Nachricht, wenn ein Wiederholungsversuch stattfindet.

  

Erweiterte Konfiguration der Wiederholungsrichtlinie

Exponentiale Rückstellung

Exponential Backoff ist eine beliebte Wiederholungsstrategie, bei der die Verzögerung zwischen Anfragen und Wiederholungsversuchen exponentiell zunimmt. Polly bietet eine bequeme Möglichkeit zur Implementierung von exponentiellem Backoff mit 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)

Wiederholung mit Unterbrecher

Die Kombination von Wiederholungsversuchen mit einem Leistungsschalter kann die Ausfallsicherheit weiter erhöhen, indem wiederholte Wiederholungsversuche verhindert werden, wenn ein Dienst ständig ausfällt. Polly ermöglicht es Ihnen, Wiederholungs- und Unterbrechungsmaßnahmen einfach zu kombinieren.

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)

In diesem Beispiel:

• CircuitBreaker() definiert eine Unterbrecherpolitik, die nach 3 Ausnahmen auslöst und 30 Sekunden lang offen bleibt.

• policy.Wrap()` fasst die Unterbrecher- und Wiederholungsrichtlinien in einer einzigen Richtlinie zusammen.

  

Einführung in IronPDF

IronPDF für C# ist eine leistungsstarke C#-Bibliothek, mit der Entwickler PDF-Dokumente in ihren .NET-Anwendungen erstellen, bearbeiten und manipulieren können. Ob Sie Rechnungen, Berichte oder andere Arten von PDF-Dokumenten erstellen müssen, IronPDF bietet eine intuitive API, die den Prozess vereinfacht.

Mit IronPDF können Sie problemlos HTML-, CSS- und sogar ASP.NET-Webseiten in PDF konvertieren, was es zu einem vielseitigen Werkzeug für eine Vielzahl von Anwendungen macht. Darüber hinaus bietet es erweiterte Funktionen wie das Hinzufügen von Text, Bildern und interaktiven Elementen zu PDFs sowie deren Sicherung durch Verschlüsselung und digitale Signaturen.

Polly Retry mit IronPDF

Bei der Arbeit mit IronPDF kann es vorkommen, dass Sie Daten aus externen Quellen abrufen oder komplexe Operationen durchführen müssen, bevor Sie eine PDF-Datei erzeugen.

In solchen Fällen kann es zu vorübergehenden Störungen oder Problemen kommen, die zu Fehlern bei der PDF-Erstellung führen können. 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, sollten Sie das IronPDF NuGet-Paket in Ihrem Projekt installieren.

Install-Package IronPdf

Verwendung von Polly Retry mit IronPDF

Schauen wir uns ein Beispiel an, in dem wir Polly Retry verwenden, um transiente Fehler bei der Erzeugung eines PDF mit IronPDF zu behandeln. Im folgenden Beispiel simulieren wir den Abruf von Daten aus einer externen API und die anschließende Erstellung einer PDF-Datei auf der Grundlage dieser Daten. Wir werden Polly Retry verwenden, um den Datenabruf im Falle von Fehlern durchzufü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)
        {
            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

Dieser C#-Code zeigt, wie die Polly-Bibliothek zur Implementierung von Wiederholungsrichtlinien mit IronPDF verwendet wird, um ein PDF-Dokument zu erzeugen. Die Methode Main initialisiert eine Wiederholungsrichtlinie unter Verwendung der Polly-Methode WaitAndRetryAsync.

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 Wiederholungen wiederholen soll. Wenn ein Wiederholungsversuch fehlschlägt, wird eine Meldung auf der Konsole ausgegeben, die die Anzahl der Wiederholungsversuche und die Ausnahmemeldung angibt.

Innerhalb der Methode Main wird die Logik der Wiederholungsrichtlinie asynchron mit retryPolicy.ExecuteAsync ausgeführt(). Bei dieser Ausführung werden zwei asynchrone Vorgänge miteinander verkettet: abrufen von Daten aus dem ExternenApiAsync() und GeneratePdfFromData(daten).

Wenn FetchDataFromExternalApiAsync() versagt (wie es absichtlich mit einer simulierten Ausnahme eingerichtet wurde)wird die Wiederholungsrichtlinie die "HttpRequestException" abfangen, den Wiederholungsversuch protokollieren und den Vorgang wiederholen.

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

Schlussfolgerung

Zusammenfassend lässt sich sagen, dass die Wiederholungsrichtlinie von Polly von unschätzbarem Wert für die Behandlung transienter Fehler und die Gewährleistung der Robustheit von C#-Anwendungen ist. Die Flexibilität bei der Konfiguration von Wiederholungsversuchen, Verzögerungen und Bedingungen ermöglicht es Entwicklern, Ausfallsicherheitsstrategien auf spezifische Anforderungen zuzuschneiden.

Ob unabhängig oder in Verbindung mit Bibliotheken wie IronPDFpolly erleichtert die Erstellung von Anwendungen, die sich nach vorübergehenden Ausfällen wiederherstellen lassen, und verbessert so die Benutzerfreundlichkeit und Zuverlässigkeit der Software.

Durch die Integration der Wiederholungsfunktionen von Polly können Entwickler widerstandsfähigere Systeme erstellen, die sich an vorübergehende Probleme anpassen und wiederherstellen können, was letztendlich die Gesamtqualität und Zuverlässigkeit ihrer Anwendungen verbessert.

IronPDF ist die beste C#-PDF-Bibliothek auf dem Markt, sie bietet auch eine testlizenz die Preise beginnen bei $749 USD.

Wenn Sie mehr über die Konvertierung von HTML in PDF mit IronPDF erfahren möchten, besuchen Sie die folgende Website link.