Was ist Polly Retry in C#?

Polly Retry ist ein Feature der Polly-Bibliothek in C#, das es Entwicklern ermöglicht, Operationen, die aufgrund vorübergehender Probleme wie Netzwerkstörungen oder Dienstunverfügbarkeit fehlschlagen, automatisch erneut zu versuchen. Dies hilft beim Aufbau widerstandsfähiger Anwendungen, indem vorübergehende Fehler elegant gehandhabt werden.

Wie kann ich eine grundlegende Retry-Richtlinie mit Polly implementieren?

Sie können eine grundlegende Retry-Richtlinie in Polly implementieren, indem Sie Ausnahmen wie HttpRequestException behandeln und sie so einstellen, dass sie maximal dreimal mit einer festen Verzögerung von zwei Sekunden zwischen jedem Versuch erneut versuchen.

Was ist die Bedeutung von Exponential Backoff in Polly?

Exponential Backoff in Polly wird verwendet, um die Verzögerung zwischen Wiederholungen exponentiell zu erhöhen, was hilft, die Last auf Diensten bei Ausfällen zu reduzieren. Dies kann mit der WaitAndRetry -Methode von Polly implementiert werden, die Verzögerungen basierend auf exponentiellem Wachstum berechnet.

Wie installiere ich Polly für ein C#-Projekt?

Sie können Polly in einem C#-Projekt mit der NuGet Package Manager Console über den Befehl Install-Package Polly oder über die .NET CLI mit dotnet add package Polly installieren.

Kann Polly's Retry-Richtlinie mit anderen Resilienzstrategien kombiniert werden?

Ja, Polly ermöglicht es, seine Retry-Richtlinie mit anderen Resilienzstrategien zu kombinieren, wie zum Beispiel einem Circuit Breaker, mithilfe der Policy.Wrap -Methode, um die Resilienz der Anwendung zu verbessern und wiederholte Wiederholungen zu verhindern, wenn ein Dienst konstant ausfällt.

Wie kann ich HTML in PDF in C# konvertieren?

Sie können die Methoden von IronPDF wie RenderHtmlAsPdf verwenden, um HTML-Strings in PDFs zu konvertieren. IronPDF unterstützt auch die Konvertierung von HTML-Dateien und Webseiten, einschließlich CSS, ins PDF-Format.

Warum ist Polly's Retry-Richtlinie wichtig für C#-Anwendungen?

Polly's Retry-Richtlinie ist entscheidend für die Behandlung vorübergehender Fehler in C#-Anwendungen, um Robustheit zu gewährleisten und die Benutzererfahrung zu verbessern, indem das System in der Lage ist, sich von vorübergehenden Ausfällen ohne Absturz zu erholen.

Wie können Retry-Strategien in einem PDF-Erstellungsprozess implementiert werden?

Beim Generieren von PDFs können Retry-Strategien mit Polly implementiert werden, um vorübergehende Fehler zu behandeln. Durch die Integration von Polly's Retry-Fähigkeiten mit IronPDF können Sie PDF-Operationen in Fällen von vorübergehenden Netzwerk- oder Dienstproblemen mehrmals versuchen.

Wie installiere ich eine C#-PDF-Bibliothek wie IronPDF?

IronPDF kann über den NuGet Package Manager mit dem Befehl Install-Package IronPDF installiert werden, wodurch Sie PDF-Dokumente innerhalb Ihrer C#-Anwendungen erstellen, bearbeiten und manipulieren können.

Welche Vorteile bietet IronPDF für die PDF-Erstellung?

IronPDF bietet leistungsstarke Funktionen zur Erstellung und Bearbeitung von PDF-Dokumenten in .NET-Anwendungen. Es unterstützt die Konvertierung von HTML, CSS und Webseiten in PDFs, das Hinzufügen von Text und Bildern und das Sichern von Dokumenten mit Verschlüsselung.

Die C# PDF-Bibliothek

Explore IronPDF Gratis testen

HTML zu PDF

Online Demo Alle Codebeispiele anzeigen

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

PM >Install-Package IronPdf

Install-Package IronPdf

ENTWICKLER-UPDATES

Polly Retry (Funktionsweise für Entwickler)

Jacob Mellor

Updated: 21. April 2026

Der Umgang mit vorübergehenden Fehlern, Zeitüberschreitungen und Ausnahmen auf elegante Weise ist entscheidend für den Aufbau robuster und widerstandsfähiger Anwendungen. Polly ist eine beliebte .NET-Bibliothek, die Resilienz- und transienten Fehlerbehandlungsmöglichkeiten bietet. Unter den vielen Funktionen ist "retry" eine der am häufigsten verwendeten Richtlinien.

In diesem Artikel werden wir uns mit Pollys Retry-Richtlinie in C# befassen, ihre Verwendung und Konfigurationsoptionen erkunden und praktische Codebeispiele bereitstellen. Außerdem verwenden wir die IronPDF Library für die PDF-Erstellung mit dem Polly Retry-Versuch, um ein PDF der Formularanfrageergebnisse 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 Fehler fehlschlagen könnten, automatisch erneut durchzuführen. Vorübergehende Fehler sind temporäre Fehler, die aufgrund von Netzwerkstörungen, Nichtverfügbarkeit von Diensten oder anderen vorübergehenden Problemen auftreten.

Mit Pollys Retrierrichtlinie können Sie Regeln für das erneute Durchführen von Operationen definieren, einschließlich der maximalen Anzahl von Wiederholungen, der Verzögerung zwischen mehreren Wiederholungen und den Bedingungen für das erneute Durchführen einer fehlgeschlagenen Anfrage. Dies hilft beim Aufbau widerstandsfähiger Anwendungen, die sich von vorübergehenden Fehlern erholen können, ohne abzustürzen oder Unterbrechungen für Endbenutzer zu verursachen.

Einstieg mit Polly Retry

Bevor wir in Codebeispiele eintauchen, verschaffen wir uns ein grundlegendes Verständnis dafür, wie Polly in einem C#-Projekt installiert und konfiguriert wird.

Installation von Polly

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

PM > Install-Package Polly

Install-Package Polly

Oder über die .NET CLI:

> dotnet add package Polly

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

Imports Polly

Basic Retry Policy Beispiel

Beginnen wir mit einem einfachen Beispiel, bei dem wir eine Operation erneut durchführen, die das Abrufen von Daten von einem Remote-Dienst simuliert. Wir werden eine Retrierichtlinie mit maximal 3 Wiederholungen und einer festen Zeitverzö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)
        {
            // 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

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

In diesem Beispiel:

Handle<HttpRequestException>() gibt an, dass wir HttpRequestException bearbeiten möchten und die Operation bei Auftreten erneut versuchen.
WaitAndRetry() konfiguriert die Wiederholungsrichtlinie mit 3 Wiederholungen und einem festen Intervall von 2 Sekunden zwischen den Wiederholungen (angegebene maximale Dauer).
onRetry Delegate protokolliert eine Nachricht, wenn eine Wiederholung auftritt.

Polly Retry (Funktionsweise für Entwickler): Abbildung 1

Erweiterte Konfiguration der Wiederholungsrichtlinie

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)

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)

Polly Retry (Funktionsweise für Entwickler): Abbildung 2

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)

' 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 CircuitBreaker-Richtlinie, die nach 3 Ausnahmen bricht und 30 Sekunden geöffnet bleibt.
Policy.Wrap() kombiniert die CircuitBreaker- und Wiederholungsrichtlinien zu einer einzigen Richtlinie.

Polly Retry (Funktionsweise für Entwickler): Abbildung 3

Einführung in IronPDF

IronPDF C# PDF Library Übersicht ist eine leistungsstarke C#-Bibliothek, die Entwicklern ermöglicht, PDF-Dokumente innerhalb ihrer .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 einfach HTML, CSS und sogar ASP.NET-Webseiten in PDFs umwandeln und so ein vielseitiges Werkzeug für eine Vielzahl von Anwendungen nutzen. Darüber hinaus bietet es erweiterte Funktionen wie das Hinzufügen von Text, Bildern und interaktiven Elementen zu PDFs sowie deren Sicherung mit Verschlüsselung und digitalen Signaturen.

IronPDF ist hervorragend in der HTML-zu-PDF-Konvertierung und gewährleistet die präzise Erhaltung der ursprünglichen Layouts und Stile. Es ist perfekt zum Erstellen von PDFs aus webbasierten Inhalten wie Berichten, Rechnungen und Dokumentationen. IronPDF unterstützt die Konvertierung 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

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

PM > Install-Package IronPdf

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 verwenden Polly Retry, um die Datenabrufoperation im Falle eines Fehlers 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

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 Main Methode initialisiert eine Wiederholungsrichtlinie mit Polly's WaitAndRetryAsync Methode.

Diese Richtlinie spezifiziert, dass es HttpRequestException bearbeiten soll und die Operation bis zu 3 Mal mit einer Verzögerung von 2 Sekunden zwischen dem ursprünglichen Versuch und den Wiederholungen erneut versuchen soll. Wenn ein Wiederholungsfehler auftritt, wird eine Nachricht in der Konsole ausgegeben, die die Anzahl der Wiederholungsversuche und die Ausnahmemeldung angibt.

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

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

Die FetchDataFromExternalApiAsync() 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.

Polly Retry (Funktionsweise für Entwickler): Abbildung 4

Abschluss

Abschließend erweist sich Pollys Retrierrichtlinie als unschätzbar wertvoll für die Handhabung vorübergehender Fehler und zur Gewährleistung von Robustheit in C#-Anwendungen. Seine Flexibilität bei der Konfiguration von Wiederholungsversuchen, Verzögerungen und Bedingungen ermöglicht Entwicklern die Anpassung von Resilienzstrategien an bestimmte Anforderungen.

Ob eigenständig oder in Verbindung mit Bibliotheken wie IronPDF verwendet, erleichtert Polly die Erstellung von Anwendungen, die sich von vorübergehenden Fehlern erholen und so die Benutzererfahrung und Zuverlässigkeit der Software verbessern.

Durch die Integration von Pollys Retrierfähigkeiten können Entwickler widerstandsfähigere Systeme aufbauen, die sich anpassen und von vorübergehenden Problemen erholen können, wodurch letztendlich die allgemeine Qualität und Zuverlässigkeit ihrer Anwendungen verbessert wird.

IronPDF ist die beste C# PDF-Bibliothek auf dem Markt, es bietet auch eine Testlizenz für IronPDF, die Preise beginnen bei $999 USD.

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

Jacob Mellor

Jetzt mit dem Ingenieurteam chatten

Chief Technology Officer

Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der Pionierarbeit in der C# PDF-Technologie leistet. Als der ursprüngliche Entwickler hinter der Kern-Codebasis von Iron Software hat er die Produktarchitektur des Unternehmens seit seiner Gründung geprägt und es zusammen mit CEO Cameron Rimington in ein Unternehmen mit mehr als 50 Mitarbeitern verwandelt, das die NASA, Tesla und globale Regierungsbehörden beliefert.

...