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 werden wir in Pollys Wiederholungsrichtlinie in C# eintauchen, ihre Verwendung erkunden, Konfigurationsmöglichkeiten und praktische Code-Beispiele bereitstellen. Außerdem werden wir die IronPDF Library for PDF Generation mit einem Polly Retry-Versuch verwenden, um ein PDF der Formularanforderungsergebnisse 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<HttpRequestException>() gibt an, dass wir HttpRequestException behandeln und die Operation erneut ausführen möchten, wenn sie auftritt.
• WaitAndRetry() konfiguriert die Wiederholungsrichtlinie mit 3 Wiederholungen und einer festen Verzögerung von 2 Sekunden zwischen den Wiederholungen (angegebene maximale Dauer).

• Der onRetry Delegate protokolliert eine Nachricht, wenn ein erneuter Versuch auftritt.

  

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, exponentielles Zurücksetzen mit WaitAndRetry() zu implementieren.

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 Circuit-Breaker-Strategie, die nach 3 Ausnahmen unterbrochen wird und 30 Sekunden geöffnet bleibt.

• Policy.Wrap() kombiniert die Schaltkreisunterbrecher- und Wiederholungspolitiken zu einer einzigen Politik.

  

Einführung in IronPDF

IronPDF C# PDF-Bibliothek Übersicht ist eine leistungsstarke C#-Bibliothek, die es Entwicklern ermöglicht, PDF-Dokumente in ihren .NET-Anwendungen zu erstellen, zu bearbeiten und zu manipulieren. 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.

IronPDF brilliert bei der HTML zu PDF Konvertierung und sorgt für die präzise Erhaltung der ursprünglichen Layouts und Stile. Es ist ideal, um PDFs aus webbasierten Inhalten wie Berichten, Rechnungen und Dokumentationen zu erstellen. IronPDF unterstützt die Umwandlung von HTML-Dateien, URLs und rohen HTML-Strings in hochwertige PDF-Dateien.

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

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 die Datenabrufoperation bei Fehlern 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)
        {
            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 Main-Methode initialisiert eine Retry-Policy mit der WaitAndRetryAsync-Methode von Polly.

Diese Richtlinie legt fest, dass sie HttpRequestException behandeln und den Vorgang bis zu 3 Mal erneut versuchen soll, mit einer Verzögerung von 2 Sekunden zwischen dem ersten Versuch und den Wiederholungen. Wenn ein Wiederholungsversuch fehlschlägt, wird eine Meldung auf der Konsole ausgegeben, die die Anzahl der Wiederholungsversuche und die Ausnahmemeldung angibt.

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

Wenn FetchDataFromExternalApiAsync() fehlschlägt (wie es absichtlich mit einer simulierten Ausnahme eingerichtet ist), wird die Wiederholungsrichtlinie die HttpRequestException abfangen, den Wiederholungsversuch protokollieren und den Vorgang erneut versuchen.

Die Methode FetchDataFromExternalApiAsync() simuliert das Abrufen von Daten von einer externen API mit einer Verzögerung und wirft absichtlich eine HttpRequestException, 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.

Egal, ob es unabhängig oder in Verbindung mit Bibliotheken wie IronPDF verwendet wird, erleichtert Polly die Erstellung von Anwendungen, die sich elegant von temporären Fehlern erholen und so die Benutzererfahrung und Zuverlässigkeit der Software verbessern.

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, es bietet auch eine Testlizenz für IronPDF an. Die Preise beginnen bei $749 USD.

Um mehr über die HTML-zu-PDF-Konvertierung mit IronPDF zu erfahren, besuchen Sie das folgende IronPDF HTML to PDF Conversion Tutorial.