Polly ist eine .NET-Bibliothek für Resilienzstrategien und transientes Fehlerhandling, die es Entwicklern ermöglicht, Resilienzrichtlinien wie Retry, Circuit Breakers, Timeout, Bulkhead Isolation und Fallback auszudrücken. Polly zielt auf ASP.NET Core ab und ist damit ein wesentliches Werkzeug für die Resilienz von .NET Core. Polly ist thread-sicher und unterstützt die Bearbeitung mehrerer gleichzeitiger Anfragen mit erfolgreichen Antworten.

Dieses Tutorial bietet weitere Details über die .NET-Bibliothek für transientes Fehlerhandling, Polly, und wie man sie mit IronPDF in einer ASP.NET Core-Anwendung verwendet. Wir werden tief in jeden Aspekt von Polly eintauchen, die Mechanismen des Circuit-Breaker-Musters erklären, Bulkhead-Isolation und Timeouts diskutieren und zeigen, wie man spezifische Ausnahmen oder fehlerhafte Dienste mit Fehlerantworten in kontrollierter, thread-sicherer Weise behandelt.

Polly-Richtlinien

Transiente Fehler treten häufig auf, wenn Ihre Anwendung versucht, über eine HTTP-Anfrage eine Verbindung zu einem Webdienst herzustellen, oder mit einer Datenbank oder anderen externen Ressourcen. Diese Fehler, wie Netzwerkfehler, temporäre Verbindungsprobleme oder Timeouts, sind kurzzeitig und beheben sich in der Regel nach kurzer Zeit von selbst.

Polly verwaltet diese transienten Fehler, indem es verschiedene Strategien anwendet und Richtlinien wie Retry Policy, erweiterte Circuit Breaker Policy, Timeout Policy, Fallback Policy und Bulkhead Isolation Policy ausdrückt.

Rettungspolitik

Die Retry Policy wiederholt fehlgeschlagene gleichzeitige Anfragen automatisch mit einer Wiederholungslogik. Es kann so konfiguriert werden, dass es ewig versucht oder automatisch eine bestimmte Anzahl von Wiederholungen macht ...

Schaltkreisunterbrecher

Die Circuit Breaker Policy ermöglicht es Ihrem System, ein Abbruch-Token zu unterstützen, um nach einer vorab konfigurierten Schwelle gescheiterter Anfragen einen bestimmten Dienst erneut zu versuchen. Die Circuit Breaker-Strategie ist vergleichbar mit Chaos Engineering oder einem Schiff, das wasserdichte Türen schließt, um den Schaden zu lokalisieren: Ein Fehler versenkt nicht das gesamte Schiff.

Timeout-Richtlinie

Die Timeout Policy erzwingt eine maximale Zeit, die ein bestimmter Abschnitt von .NET-Resilienzkode ausführen darf. Es kommt in zwei Varianten: optimistisches Timeout und pessimistisches Timeout.

Rückrufpolitik

Die Fallback-Policy wird verwendet, um im Falle eines Fehlers einen Ersatzwert oder ein Ersatzverhalten bereitzustellen. Diese Richtlinie kann nützlich sein, wenn ein scheiternder Dienst den gesamten Prozess nicht stoppen sollte.

Bulkhead-Isolierung

Bulkhead Isolation wird verwendet, um die Anzahl gleichzeitiger Anfragen an einen bestimmten Vorgang zu begrenzen, wodurch das Potenzial für Socket-Auspuffung begrenzt und eine kontrollierte Anzahl von Ausführungsplätzen aufrechterhalten wird.

Cache-Richtlinie

Die Cache Policy speichert die erfolgreiche Antwort einer Ausführung, sodass Polly den verteilten Cache-Wert zurückgeben kann, wenn dieselbe Ausführung erneut aufgerufen wird.

Richtlinienübersicht

Ermöglicht uns, mehrere Richtlinien zusammenzubinden, sodass sie als eine einzige Einheit arbeiten.

Richtlinien erstellen und konfigurieren

Rettungspolitik

Eine Retry-Policy ist einfach: Wenn eine spezifische Ausnahme oder ein Fehler auftritt, versucht Polly, den zugrunde liegenden Delegaten erneut auszuführen. Sie können definieren, wie oft erneut versucht werden soll, das Zeitintervall zwischen den Wiederholungen oder eine exponentielle Back-off-Strategie verwenden, andernfalls versucht es ewig erneut. Hier ist ein Beispiel:

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

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

Schaltkreisunterbrecher-Richtlinie

Die Circuit Breaker Policy lässt die Polly-Bibliothek nach Fehlern überwachen, und wenn die Anzahl der Fehler einen konfigurierten Schwellenwert in einem bestimmten Zeitraum überschreitet, wird der Stromkreis "unterbrochen" und weitere Anfragen werden für einen bestimmten Zeitraum blockiert. Dies wird als "offener" Zustand bezeichnet. Nach dieser Zeit geht der Stromkreis in einen "halb-offenen" Zustand über, in dem er etwas Verkehr zulässt, um die Gesundheit des bestimmten Dienstes zu überprüfen. Wenn diese Anfragen erfolgreich sind und keine Fehler auftreten, schließt sich der Stromkreis; ansonsten öffnet er sich wieder.

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

' Circuit breaker policy to handle failing requests with open and half-open states
Dim circuitBreakerPolicy = Policy.Handle(Of HttpRequestException)().CircuitBreakerAsync(5, TimeSpan.FromMinutes(1))

Timeout-Richtlinie

Timeout-Policies behandeln Szenarien, in denen ein Dienst nicht innerhalb eines angemessenen Zeitrahmens antwortet. Polly bietet zwei Arten von Timeouts: optimistisch und pessimistisch. Ein optimistisches Timeout arbeitet auf einem separaten Thread und storniert die zugrunde liegende Operation über einen CancellationToken. Ein pessimistisches Timeout blockiert den übergeordneten Thread, bis die Operation abgeschlossen ist oder die Timeout-Periode abgelaufen ist.

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

' Timeout policy with a 30-second optimistic timeout
Dim timeoutPolicy = Policy.TimeoutAsync(30) ' 30 seconds

Bulkhead-Isolierung

Bulkhead Isolation wird verwendet, um die Anzahl gleichzeitiger Aktionen gegen einen bestimmten Dienst zu begrenzen. Es bietet eine Möglichkeit, Fehler zu isolieren und zu verhindern, dass sie sich fortpflanzen. Es begrenzt auch die Last, die wir auf unsere Abhängigkeiten legen.

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

' Bulkhead isolation policy to limit concurrency and queue length
Dim bulkheadIsolationPolicy = Policy.BulkheadAsync(10, 20) ' 10 concurrent actions, 20 queue slots

Rückrufpolitik

Fallback-Policies sind nützlich, wenn Sie ein Standardverhalten oder einen Ersatzwert bereitstellen müssen, wenn alle anderen Maßnahmen versagen.

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

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

Verpacken der Richtlinien

Mehrere Richtlinien können flexibel mit einem PolicyWrap kombiniert werden:

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

' Combining multiple policies using PolicyWrap
Dim policyWrap = Policy.WrapAsync(fallbackPolicy, retryPolicy, circuitBreakerPolicy, timeoutPolicy, bulkheadIsolationPolicy)

Einstieg

Um Polly mit IronPDF zu verwenden, stellen Sie sicher, dass Sie Visual Studio installiert haben und erstellen Sie ein neues Konsolenanwendungsprojekt in .NET Core. Öffnen Sie die NuGet-Paketmanager-Konsole in Visual Studio und installieren Sie die Polly und IronPDF Pakete:

Install-Package Polly

Install-Package IronPdf

Verwendung von Polly mit IronPDF Konvertierung einer URL in PDF

Ein herausragendes Merkmal von IronPDF ist seine HTML-zu-PDF-Fähigkeit, die sicherstellt, dass Layouts und Stile intakt bleiben. Diese Funktion verwandelt Webinhalte in PDFs, was sich perfekt für Berichte, Rechnungen und Dokumentationen eignet. Es unterstützt die Konvertierung von HTML-Dateien, URLs und HTML-Zeichenfolgen in PDFs.

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

Lassen Sie uns ein Beispiel für die Verwendung von Polly mit IronPDF zum Konvertieren einer URL in PDF durchgehen. Angenommen, wir haben einen Webdienst, der gelegentlich aufgrund transienter Fehler ausfällt, und wir möchten diese Fehler mit Polly elegant handhaben.

Zuerst importieren wir die notwendigen Namespaces in unsere Program.cs Datei:

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

Imports System
Imports System.Threading.Tasks
Imports Polly
Imports Polly.Wrap
Imports IronPdf

Als Nächstes definieren wir unsere Richtlinien. In diesem Beispiel verwenden wir eine Kombination aus Retry- und Circuit-Breaker-Richtlinien, um Fehler zu handhaben:

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

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

Der retryPolicy wird den fehlgeschlagenen Anruf bis zu dreimal mit einer exponentiellen Backoff-Strategie wiederholen, dabei 2 Sekunden, 4 Sekunden und 8 Sekunden zwischen den Wiederholungen warten. Der circuitBreakerPolicy wird den Stromkreis öffnen, wenn zwei aufeinanderfolgende Ausfälle innerhalb eines 30-Sekunden-Zeitintervalls auftreten.

Nun definieren wir unseren IronPDF-Code, um eine URL in ein PDF zu konvertieren:

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

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

Im obigen Beispielcode umschließen wir unsere retryPolicy und circuitBreakerPolicy mit der WrapAsync Methode. Dies ermöglicht es uns, mehrere Richtlinien nacheinander auf neue Anfragen anzuwenden. Die ExecuteAsync Methode führt den bereitgestellten Delegaten aus, welcher in diesem Code die RenderUrlAsPdfAsync Methode von IronPDF ist.

Durch die Anwendung von Polly-Richtlinien stellen wir sicher, dass unser Code gegen transiente Fehler widerstandsfähig ist. Wenn eine Anfrage fehlschlägt, wird Polly sie automatisch gemäß der Retry-Policy erneut versuchen. Wenn die Anzahl der aufeinanderfolgenden Fehler die vorab konfigurierte Schwelle überschreitet, öffnet die Circuit-Breaker-Policy den Stromkreis und verhindert weitere Anfragen für eine bestimmte Dauer.

Testfälle für Polly Policies

Um die Effektivität unserer Polly-Richtlinien zu testen, simulieren wir einige fehlgeschlagene Anfragen. Ändern Sie die URL zu einem nicht existierenden Endpunkt und fügen Sie einige Testfälle hinzu:

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

Imports System

Dim testUrls = {
    "https://ironpdf.com",
    "https://notexistingdomain.com/",
    "http://httpbin.org/delay/120"
}

For Each url In testUrls
    Try
        Dim pdfBytes = Await retryPolicy _
            .WrapAsync(circuitBreakerPolicy) _
            .ExecuteAsync(Function() htmlToPdf.RenderUrlAsPdfAsync(url))

        pdfBytes.SaveAs($"{Guid.NewGuid()}.pdf")
        Console.WriteLine($"Successfully converted {url} to PDF.")
    Catch ex As Exception
        Console.WriteLine($"Failed to convert {url} to PDF: {ex.Message}")
    End Try
Next

Imports System

Dim testUrls = {
    "https://ironpdf.com",
    "https://notexistingdomain.com/",
    "http://httpbin.org/delay/120"
}

For Each url In testUrls
    Try
        Dim pdfBytes = Await retryPolicy _
            .WrapAsync(circuitBreakerPolicy) _
            .ExecuteAsync(Function() htmlToPdf.RenderUrlAsPdfAsync(url))

        pdfBytes.SaveAs($"{Guid.NewGuid()}.pdf")
        Console.WriteLine($"Successfully converted {url} to PDF.")
    Catch ex As Exception
        Console.WriteLine($"Failed to convert {url} to PDF: {ex.Message}")
    End Try
Next

Im obigen Code iterieren wir über eine Reihe von Test-URLs und versuchen, jede von ihnen in PDF zu konvertieren. Wenn eine Anfrage fehlschlägt, wird die Ausnahme abgefangen und eine entsprechende Nachricht in der Konsole angezeigt.

Abschluss

Polly ist eine leistungsstarke und flexible Bibliothek für die Implementierung von Resilienz und transientem Fehlerhandling in .NET Core-Anwendungen. Durch das Kombinieren von Richtlinien wie Retry und Circuit Breaker können Entwickler robuste und fehlertolerante Systeme bauen, die Fehler elegant handhaben.

In diesem Tutorial haben wir gelernt, wie man Polly mit IronPDF verwendet, um eine URL in PDF zu konvertieren. Wir haben gelernt, wie man Polly-Richtlinien definiert und anwendet, einschließlich Retry und Circuit Breaker. Wir haben auch unsere Richtlinien mit verschiedenen URLs getestet. Wir können es auch für die Konvertierung von HTML zu PDF tun.

IronPDF bietet eine kostenlose Testversion, und Lizenzen beginnen zu wettbewerbsfähigen Preisen, sodass Sie seine Fähigkeiten in Ihren Projekten nutzen können.