Ikona wiadomości
Przejdź do treści stopki
  1. IronPDF
  2. Blog IronPDF
  3. Pomoc .NET
  4. .NET Core Polly
POMOC .NET

.NET Core Polly (jak to działa dla programistów)

Jacob Mellor, Dyrektor Technologiczny @ Team Iron
Jacob Mellor
Zaktualizowano:

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 systemówi 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)
$vbLabelText   $csharpLabel

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))
$vbLabelText   $csharpLabel

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 limit czasu działa w oddzielnym wątku i anuluje operację bazową 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
$vbLabelText   $csharpLabel

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
$vbLabelText   $csharpLabel

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)
$vbLabelText   $csharpLabel

Podsumowanie zasad

Wiele zasad można elastycznie łączyć za pomocą 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)
$vbLabelText   $csharpLabel

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 oraz 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
$vbLabelText   $csharpLabel

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 do naszego 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
$vbLabelText   $csharpLabel

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))
$vbLabelText   $csharpLabel

retryPolicy ponowi nieudane żądanie maksymalnie trzy razy, stosując strategię wykładniczego opóźnienia, czekając 2 sekundy, 4 sekundy i 8 sekund między kolejnymi próbami. circuitBreakerPolicy spowoduje otwarcie obwodu, jeśli w ciągu 30 sekund wystąpią dwie kolejne awarie.

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")
$vbLabelText   $csharpLabel

W powyższym przykładowym kodzie otaczamy nasze retryPolicy i circuitBreakerPolicy za pomocą metody WrapAsync. Pozwala nam to na sekwencyjne stosowanie wielu zasad do nowych wniosków. Metoda ExecuteAsync wykonuje podany delegat, którym w tym kodzie jest metoda RenderUrlAsPdfAsync z biblioteki 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
$vbLabelText   $csharpLabel

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.

.NET Core Polly (jak to działa dla programistów): Rysunek 1 – URL do pliku PDF

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.

Często Zadawane Pytania

Czym jest Polly i w jaki sposób zwiększa odporność platformy .NET Core?

Polly to biblioteka .NET zaprojektowana z myślą o odporności i obsłudze przejściowych błędów, szczególnie w aplikacjach ASP.NET Core. Zwiększa odporność, oferując strategie takie jak Retry, Circuit Breakers, Timeout, Bulkhead Isolation i Fallback, zapewniając solidne i odporne na awarie systemy.

Jak mogę użyć Polly do wdrożenia polityki ponownych prób w .NET Core?

W .NET Core można użyć Polly do wdrożenia polityki ponawiania prób (Retry Policy), konfigurując ją tak, aby automatycznie ponawiała nieudane żądania. Można to zrobić, ustawiając liczbę ponownych prób i odstęp czasu między nimi, co pozwala na skuteczne zarządzanie przejściowymi błędami.

W jaki sposób polityka Circuit Breaker zapobiega kaskadowym awariom w aplikacjach .NET?

Polityka Circuit Breaker w Polly zapobiega kaskadowym awariom poprzez monitorowanie błędów i otwieranie obwodu w celu blokowania żądań po osiągnięciu progu awarii. Powoduje to zatrzymanie dalszych żądań do momentu zresetowania obwodu, co pozwala systemówi na odzyskanie sprawności przed przyjęciem nowych żądań.

Jaką rolę odgrywa izolacja przegrodowa w zarządzaniu wyczerpaniem zasobów?

Izolacja typu bulkhead w Polly ogranicza liczbę jednoczesnych żądań kierowanych do usługi, zapobiegając wyczerpaniu zasobów poprzez kontrolowanie slotów wykonawczych. Ta polityka pomaga ograniczyć awarie i zapewnia efektywne zarządzanie zasobami w aplikacji .NET Core.

W jaki sposób polityka limitów czasu Polly może poprawić szybkość działania mojej aplikacji?

Polityka limitów czasu Polly narzuca maksymalny czas wykonania operacji, co pomaga w zarządzaniu sytuacjami, w których usługi nie odpowiadają natychmiast. Ustawiając optymistyczne lub pesymistyczne limity czasu, programiści mogą zapewnić, że ich aplikacje pozostaną responsywne.

Czy Polly może służyć do zwiększenia niezawodności konwersji adresów URL na pliki PDF?

Tak, Polly może zwiększyć niezawodność konwersji adresów URL do formatu PDF poprzez integrację swoich zasad ponawiania prób i wyłączania awaryjnego z narzędziami do generowania plików PDF. Zapewnia to odporność procesów konwersji na przejściowe awarie, zachowując niezawodność.

W jaki sposób polityka rezerwowa w Polly zapewnia płynne obniżenie jakości usługi?

Polityka awaryjna w Polly zapewnia alternatywne reakcje lub zachowania w przypadku awarii usługi. Pomaga to zapewnić, że awaria nie zatrzyma całej aplikacji, umożliwiając płynne przejście do trybu awaryjnego i kontynuację działania.

Jak połączyć wiele zasad Polly w aplikacji .NET?

W aplikacji .NET można łączyć wiele zasad Polly za pomocą Policy Wraps. Pozwala to programistom na wspólne stosowanie różnych strategii odporności, umożliwiając bardziej kompleksowe i elastyczne podejście do obsługi błędów.

W jaki sposób integracja Polly z IronPDF radzi sobie z przejściowymi błędami podczas generowania plików PDF?

Dzięki integracji Polly z IronPDF programiści mogą radzić sobie z przejściowymi błędami podczas generowania plików PDF za pomocą takich mechanizmów jak ponowne próby i wyłącznik awaryjny. Integracja ta zapewnia stabilne i niezawodne generowanie plików PDF pomimo sporadycznych zakłóceń w działaniu usługi.

Jakie są typowe strategie rozwiązywania problemów podczas korzystania z Polly w środowisku .NET Core?

Typowe strategie rozwiązywania problemów obejmują weryfikację konfiguracji zasad, takich jak interwały ponownych prób i progi wyłączników awaryjnych, oraz testowanie zasad w różnych scenariuszach w celu zapewnienia prawidłowego postępowania w przypadku awarii i odporności systemu.

Jacob Mellor, Dyrektor Technologiczny @ Team Iron
Jacob Mellor
  Czat z zespołem inżynierów teraz
Dyrektor ds. technologii

Jacob Mellor jest Chief Technology Officer w Iron Software i wizjonerskim inżynierem, pionierem technologii C# PDF. Jako pierwotny deweloper głównej bazy kodowej Iron Software, kształtuje architekturę produktów firmy od jej początku, przekształcając ją wspólnie z CEO Cameron Rimington w firmę liczą...

Czytaj więcej

Powiązane artykuły

30-dniowy okres próbny → Pełna wersja produktu. Bez ograniczeń. Bez karty. Bezpłatna próba

Zespol wsparcia Iron

Jestesmy online 24 godziny, 5 dni w tygodniu.
Czat
Email
Zadzwon do mnie