Polly to biblioteka strategii odporności i obsługi błędów przejściowych w środowisku .NET, umożliwiająca programistom definiowanie zasad odporności, takich jak polityka ponownych prób, wyłączniki obwodów, limity czasu, polityka izolacji przegród oraz rezerwy. Polly jest przeznaczona dla ASP.NET Core, co czyni ją niezbędnym narzędziem zapewniającym odporność .NET Core. Polly jest bezpieczna dla wątków i obsługuje wiele równoczesnych żądań z pomyślnymi odpowiedziami.

W tym samouczku znajdziesz więcej szczegółów na temat biblioteki .NET do obsługi błędów przejściowych, Polly, oraz tego, jak używać jej z IronPDF w aplikacji ASP.NET Core. Zagłębimy się w każdy aspekt Polly, wyjaśnimy mechanikę wzorca wyłącznika awaryjnego, omówimy izolację przegrody i limity czasu oraz pokażemy, jak radzić sobie z konkretnymi wyjątkami lub awariami usług za pomocą odpowiedzi o błędzie w kontrolowany, bezpieczny dla wątków sposób.

Zasady Polly

Często zdarzają się przejściowe błędy, gdy aplikacja próbuje połączyć się z usługą internetową za pośrednictwem żądania HTTP, bazy danych lub innych zasobów zewnętrznych. Te usterki, takie jak awarie sieci, tymczasowe problemy z łącznością lub przekroczenia limitów czasu, są krótkotrwałe i zazwyczaj ustępują same po krótkim czasie.

Polly zarządza tymi przejściowymi błędami, stosując różne strategie i polityki, takie jak polityka ponownych prób, zaawansowana polityka wyłącznika automatycznego, polityka limitów czasowych, polityka rezerwowa oraz polityka izolacji przegród.

Polityka ponownych prób

Polityka ponownych prób automatycznie ponawia nieudane żądania równoległe przy użyciu logiki ponownych prób. Można go skonfigurować tak, aby ponawiał próby w nieskończoność lub automatycznie ponawiał je określoną liczbę razy, a także może czekać przez ustalony odstęp czasu między ponownymi próbami lub stosować wykładniczy odstęp czasowy.

Wyłącznik automatyczny

Polityka Circuit Breaker pozwala systemowi obsługiwać token anulowania, umożliwiający ponowne wywołanie danej usługi po przekroczeniu wstępnie skonfigurowanego progu nieudanych żądań. Strategia Circuit Breaker jest analogiczna do inżynierii chaosu lub statku zamykającego wodoszczelne drzwi w celu lokalizacji uszkodzeń: jedna awaria nie zatopi całego statku.

Zasady dotyczące terminów

Polityka limitów czasu określa maksymalny czas, w którym dany fragment kodu odpornościowego .NET może zostać wykonany. Występuje w dwóch odmianach: optymistycznym limicie czasu i pesymistycznym limicie czasu.

Polityka rezerwowa

Polityka rezerwowa służy do zapewnienia wartości zastępczej lub zachowania zastępczego w przypadku awarii. Ta polityka może być przydatna, gdy awaria usługi nie powinna zatrzymywać całego procesu.

Izolacja przegrodowa

Izolacja typu bulkhead służy do ograniczenia liczby równoczesnych żądań kierowanych do konkretnej operacji, co ogranicza ryzyko wyczerpania gniazd i pozwala utrzymać kontrolowaną liczbę slotów wykonawczych.

Polityka pamięci podręcznej

Polityka pamięci podręcznej buforuje pomyślną odpowiedź wykonania, dzięki czemu w przypadku ponownego wywołania tego samego wykonania Polly może zwrócić wartość z pamięci podręcznej.

Podsumowanie zasad

Pozwala nam to połączyć wiele zasad w jedną całość, dzięki czemu mogą one działać jako pojedyncza jednostka.

Tworzenie i konfigurowanie zasad

Polityka ponownych prób

Zasady ponownej próby są proste: gdy wystąpi określony wyjątek lub błąd, Polly spróbuje ponownie wykonać podstawowego delegata. Można określić liczbę ponownych prób, odstęp czasu między nimi lub zastosować strategię wykładniczego cofania, w przeciwnym razie próby będą powtarzane w nieskończoność. Oto przykład:

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

Polityka wyłączania awaryjnego

Polityka Circuit Breaker pozwala bibliotece Polly monitorować błędy, a jeśli liczba błędów przekroczy skonfigurowany próg w określonym czasie, obwód zostaje "przerwany", a dalsze żądania są blokowane na określony czas. Nazywa się to stanem "otwartym". Po upływie tego czasu obwód przechodzi w stan "półotwarty", w którym zezwala na przepływ pewnej ilości ruchu w celu sprawdzenia stanu danej usługi. Jeśli żądania te zakończą się powodzeniem i nie wystąpią żadne błędy, obwód zostaje zamknięty; w przeciwnym razie otworzy się ponownie.

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

Zasady dotyczące terminów

Zasady dotyczące limitów czasu obsługują scenariusze, w których usługa nie odpowiada w rozsądnym terminie. Polly oferuje dwa rodzaje limitów czasu: optymistyczny i pesymistyczny. Optymistyczny czas oczekiwania działa na osobnym wątku i anuluje proces pośrednio za pomocą CancellationToken. Pesymistyczny limit czasu blokuje wątek nadrzędny do momentu zakończenia operacji lub upływu limitu czasu.

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

Izolacja przegrodowa

Izolacja typu bulkhead służy do ograniczania liczby równoczesnych operacji wykonywanych na danej usłudze. Umożliwia ona izolowanie błędów i zapobieganie ich kaskadowemu rozprzestrzenianiu się. Ogranicza to również obciążenie naszych zależności.

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

Polityka rezerwowa

Zasady rezerwowe są przydatne, gdy trzeba zapewnić domyślne zachowanie lub wartość zastępczą, gdy wszystko inne zawiedzie.

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

Podsumowanie zasad

Wiele polityk można elastycznie łączyć, korzystając z PolicyWrap:

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

Pierwsze kroki

Aby rozpocząć korzystanie z Polly w połączeniu z IronPDF, upewnij się, że masz zainstalowane Visual Studio, a następnie utwórz nowy projekt aplikacji konsolowej w .NET Core. Otwórz konsolę Menedżera pakietów NuGet w Visual Studio i zainstaluj pakiety Polly i IronPDF:

Install-Package Polly

Install-Package IronPdf

Korzystanie z Polly z IronPDF Konwersja adresu URL do formatu PDF

Wyróżniającą cechą IronPDF jest możliwość konwersji HTML do PDF, która zapewnia zachowanie układów i stylów. Ta funkcja przekształca treści internetowe w pliki PDF, co idealnie sprawdza się w przypadku raportów, faktur i dokumentacji. Obsługuje konwersję plików HTML, adresów URL i ciągów znaków HTML do formatu 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");
    }
}

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

Przeanalizujmy przykład wykorzystania Polly wraz z IronPDF do konwersji adresu URL do formatu PDF. Załóżmy, że mamy usługę internetową, która czasami ulega awarii z powodu przejściowych usterek i chcemy elegancko obsłużyć te awarie za pomocą Polly.

Najpierw zaimportujmy niezbędne przestrzenie nazw w naszym pliku Program.cs:

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

Następnie zdefiniujemy nasze zasady. W tym przykładzie użyjemy kombinacji zasad ponownych prób i wyłączników awaryjnych do obsługi błędów:

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

retryPolicy będzie ponawiać nieudaną próbę do trzech razy z wykładniczą strategią wycofania, czekając 2 sekundy, 4 sekundy i 8 sekund między próbami ponownego wykonania. circuitBreakerPolicy otworzy obwód, jeśli dwa kolejne niepowodzenia wystąpią w czasie krótszym niż 30 sekund.

Teraz zdefiniujmy nasz kod IronPDF do konwersji adresu URL na plik 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");

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

W powyższym przykładzie kodu otaczamy nasze retryPolicy i circuitBreakerPolicy używając metody WrapAsync. Pozwala nam to na sekwencyjne stosowanie wielu zasad do nowych wniosków. Metoda ExecuteAsync wykonuje przekazany delegat, który w tym kodzie jest metodą RenderUrlAsPdfAsync z IronPDF.

Stosując zasady Polly, zapewniamy, że nasz kod jest odporny na przejściowe awarie. Jeśli żądanie zakończy się niepowodzeniem, Polly automatycznie ponowi próbę zgodnie z zasadami ponawiania prób. Jeśli liczba kolejnych niepowodzeń przekroczy wstępnie skonfigurowany próg, polityka wyłącznika automatycznego spowoduje otwarcie obwodu, uniemożliwiając dalsze żądania przez określony czas.

Przykłady testowe dla zasad Polly

Aby sprawdzić skuteczność naszych zasad Polly, zasymulujmy kilka nieudanych żądań. Zmodyfikuj adres URL na nieistniejący punkt końcowy i dodaj kilka przypadków testowych:

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

W powyższym kodzie iterujemy nad zestawem testowych adresów URL i próbujemy przekonwertować każdy z nich do formatu PDF. Jeśli żądanie zakończy się niepowodzeniem, wyjątek zostanie przechwycony, a w konsoli wyświetli się odpowiedni komunikat.

Wnioski

Polly to potężna i elastyczna biblioteka służąca do wdrażania odporności i obsługi błędów przejściowych w aplikacjach .NET Core. Łącząc takie mechanizmy jak ponowne próby i wyłącznik obwodu, programiści mogą tworzyć solidne i odporne na awarie systemy, które płynnie radzą sobie z niepowodzeniami.

W tym samouczku omówiliśmy, jak używać Polly z IronPDF do konwersji adresu URL na plik PDF. Dowiedzieliśmy się, jak definiować i stosować zasady Polly, w tym ponowne próby i wyłącznik obwodu. Przetestowaliśmy również nasze zasady na różnych adresach URL. Możemy również wykonać to zadanie w przypadku konwersji HTML do PDF.

IronPDF oferuje bezpłatną wersję próbną, a ceny licencji zaczynają się od konkurencyjnych stawek, co pozwala wykorzystać jego możliwości w swoich projektach.