.NET-HILFE

.NET Core Polly (Wie es für Entwickler funktioniert)

Veröffentlicht 26. Juli 2023

Teilen Sie:

Polly ist eine .NET-Bibliothek für Ausfallsicherheitsstrategien und die Behandlung transienter Fehler, die es Entwicklern ermöglicht, Ausfallsicherheitsrichtlinien wie Wiederholungsrichtlinien, Circuit Breakers, Timeout, Bulkhead-Isolationsrichtlinien und Fallback zu formulieren. Polly zielt auf ASP.NET Core und ist damit ein wichtiges Werkzeug für die Resilienz von .NET Core. Polly ist thread-sicher und unterstützt die Bearbeitung mehrerer gleichzeitiger Anfragen mit erfolgreicher Antwort.

In diesem Tutorial erfahren Sie mehr über die .NET-Bibliothek Polly zur Behandlung transienter Fehler und wie Sie sie mit IronPDF in einer ASP.NET Core-Anwendung. Wir tauchen tief in jeden Aspekt von Polly ein, erklären die Mechanik des Circuit-Breaker-Musters, besprechen Bulkhead-Isolation und Timeouts und zeigen, wie man bestimmte Ausnahmen oder fehlgeschlagene Dienste mit Fehlerreaktionen auf kontrollierte, thread-sichere Weise behandelt.

Polly Policies

Vorübergehende Fehler treten häufig auf, wenn Ihre Anwendung versucht, über eine HTTP-Anforderung, eine Datenbank oder andere externe Ressourcen eine Verbindung mit einem Webdienst herzustellen. Diese Fehler, wie z. B. Netzwerkausfälle, vorübergehende Verbindungsprobleme oder Zeitüberschreitungen, sind kurz und werden in der Regel nach kurzer Zeit behoben.

Polly verwaltet diese transienten Fehler durch die Anwendung verschiedener Strategien und ausdrücklicher Richtlinien wie Wiederholungsrichtlinien, erweiterte Circuit-Breaker-Richtlinien, Timeout-Richtlinien, Fallback-Richtlinien und Bulkhead-Isolierungsrichtlinien.

Wiederholungspolitik

Die Wiederholungsrichtlinie wiederholt automatisch fehlgeschlagene gleichzeitige Anfragen mit Hilfe einer Wiederholungslogik. Er kann so konfiguriert werden, dass er es immer wieder versucht oder eine bestimmte Anzahl automatischer Wiederholungen vornimmt, und er kann ein bestimmtes Zeitintervall zwischen den Wiederholungen abwarten oder einen exponentiellen Backoff verwenden.

Stromkreisunterbrecher

Die Circuit Breaker-Richtlinie ermöglicht es Ihrem System, Token für den Abbruch eines bestimmten Dienstes zu unterstützen, nachdem eine bestimmte Anzahl von Anfragen fehlgeschlagen ist. Die Circuit-Breaker-Strategie ist vergleichbar mit dem Chaos-Engineering oder einem Schiff, das die wasserdichten Türen schließt, um den Schaden zu begrenzen: Ein Fehler wird nicht das ganze Schiff versenken.

Timeout-Politik

Die Timeout-Richtlinie erzwingt eine maximale Zeitspanne, in der ein bestimmtes Stück .NET Resilience-Code ausgeführt werden kann. Es gibt sie in zwei Varianten: optimistische Zeitüberschreitung und pessimistische Zeitüberschreitung.

Ausweichpolitik

Die Fallback-Policy wird verwendet, um im Falle eines Ausfalls einen Ersatzwert oder ein Ersatzverhalten bereitzustellen. Diese Richtlinie kann nützlich sein, wenn ein ausfallender Dienst nicht den gesamten Prozess anhalten soll.

Schott-Isolierung

Die Bulkhead-Isolierung wird verwendet, um zu begrenzen, wie viele gleichzeitige Anfragen an eine bestimmte Operation gestellt werden können, wodurch das Potenzial für eine Socket-Erschöpfung begrenzt und eine kontrollierte Anzahl von Ausführungsslots aufrechterhalten wird.

Cache-Politik

Die Cache-Richtlinie speichert die erfolgreiche Antwort auf eine Ausführung, so dass Polly bei einem erneuten Aufruf derselben Ausführung den verteilten Cache-Wert zurückgeben kann.

Policy Wrap

Ermöglicht es uns, mehrere Policen zusammenzufassen, so dass sie als eine Einheit funktionieren können.

Erstellen und Konfigurieren von Policen

Wiederholungspolitik

Eine Wiederholungsrichtlinie ist einfach: Wenn eine bestimmte Ausnahme oder ein Fehler auftritt, wird Polly versuchen, den zugrunde liegenden Delegaten erneut auszuführen. Sie können die Anzahl der Wiederholungsversuche und das Zeitintervall zwischen den Wiederholungsversuchen festlegen oder eine exponentielle Rückzugsstrategie verwenden, andernfalls wird der Versuch ewig wiederholt. Hier ist ein Beispiel:

//extension method
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
    });

//extension method
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
    });

'extension method
Dim retryPolicy = Policy.Handle(Of HttpRequestException)().WaitAndRetryAsync(3, Function(retryAttempt) TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), Sub(exception, timeSpan, retryCount, context)
End Sub)

VB C#

Unterbrecherpolitik

Wenn die Anzahl der Fehler innerhalb eines bestimmten Zeitraums einen konfigurierten Schwellenwert überschreitet, wird der Stromkreis "unterbrochen", und weitere Anfragen werden für eine bestimmte Zeit blockiert. Dies wird als "offener" Zustand bezeichnet. Nach dieser Zeit geht die Schaltung in einen "halboffenen" Zustand über, in dem sie einen gewissen Verkehr zulässt, um den Zustand des jeweiligen Dienstes zu überprüfen. Wenn diese Anfragen erfolgreich sind und keine Fehler auftreten, schließt sich die Schaltung, andernfalls wird sie wieder geöffnet.

var circuitBreakerPolicy = Policy
    .Handle<HttpRequestException>()
    .CircuitBreakerAsync(5, TimeSpan.FromMinutes(1));

var circuitBreakerPolicy = Policy
    .Handle<HttpRequestException>()
    .CircuitBreakerAsync(5, TimeSpan.FromMinutes(1));

Dim circuitBreakerPolicy = Policy.Handle(Of HttpRequestException)().CircuitBreakerAsync(5, TimeSpan.FromMinutes(1))

VB C#

Timeout-Politik

Zeitüberschreitungsrichtlinien behandeln Szenarien, in denen ein Dienst nicht innerhalb eines angemessenen Zeitrahmens antwortet. Polly bietet zwei Arten von Zeitüberschreitungen an: Optimistisch und pessimistisch. Eine optimistische Zeitüberschreitung arbeitet auf einem separaten Thread und bricht die zugrunde liegende Operation über ein CancellationToken ab. Eine pessimistische Zeitüberschreitung blockiert den übergeordneten Thread, bis der Vorgang abgeschlossen ist oder die Zeitüberschreitung abläuft.

var timeoutPolicy = Policy.TimeoutAsync(30); // Optimistic timeout of 30 seconds

var timeoutPolicy = Policy.TimeoutAsync(30); // Optimistic timeout of 30 seconds

IRON VB CONVERTER ERROR developers@ironsoftware.com

VB C#

Schott-Isolierung

Die Bulkhead-Isolierung wird verwendet, um die Anzahl der gleichzeitigen Aktionen gegen einen bestimmten Dienst zu begrenzen. Sie bietet eine Möglichkeit, Fehler zu isolieren und zu verhindern, dass sie kaskadieren. Dadurch wird auch die Belastung unserer Abhängigkeiten begrenzt.

var bulkheadIsolationPolicy = Policy.BulkheadAsync(10, 20); // 10 concurrent actions, queue 20 additional actions

var bulkheadIsolationPolicy = Policy.BulkheadAsync(10, 20); // 10 concurrent actions, queue 20 additional actions

IRON VB CONVERTER ERROR developers@ironsoftware.com

VB C#

Ausweichpolitik

Fallback-Richtlinien sind nützlich, wenn Sie ein Standardverhalten oder einen Ersatzwert bereitstellen müssen, wenn alles andere fehlschlägt.

var fallbackPolicy = Policy
    .Handle<Exception>()
    .FallbackAsync<FallbackResult>(FallbackResult.SomethingWentWrong);

var fallbackPolicy = Policy
    .Handle<Exception>()
    .FallbackAsync<FallbackResult>(FallbackResult.SomethingWentWrong);

Dim fallbackPolicy = Policy.Handle(Of Exception)().FallbackAsync(Of FallbackResult)(FallbackResult.SomethingWentWrong)

VB C#

Einpacken der Policen

Mehrere Richtlinien können mit Hilfe einer "PolicyWrap" flexibel kombiniert werden:

var policyWrap = Policy.WrapAsync(fallbackPolicy, retryPolicy, circuitBreakerPolicy, timeoutPolicy, bulkheadIsolationPolicy);

var policyWrap = Policy.WrapAsync(fallbackPolicy, retryPolicy, circuitBreakerPolicy, timeoutPolicy, bulkheadIsolationPolicy);

IRON VB CONVERTER ERROR developers@ironsoftware.com

VB C#

Erste Schritte

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 Pakete "Polly" und "IronPDF":

Install-Package Polly

Install-Package IronPdf

Verwendung von Polly mit IronPDF Konvertieren einer URL in PDF

Ein herausragendes Merkmal von IronPDF ist seine HTML zu PDF fähigkeit, sicherzustellen, dass Layouts und Stile intakt sind. Diese Funktion wandelt Webinhalte in PDF-Dateien um, die sich hervorragend für Berichte, Rechnungen und Dokumentationen eignen. Es unterstützt die Umwandlung von HTML-Dateien, URLs und HTML-Strings 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

VB C#

Lassen Sie uns ein Beispiel für die Verwendung von Polly mit IronPDF durchgehen, um eine URL in PDF umwandeln. Angenommen, wir haben einen Webdienst, der gelegentlich aufgrund vorübergehender Fehler ausfällt, und wir wollen diese Fehler mit Polly zuverlässig behandeln.

Zunächst importieren wir die erforderlichen Namespaces in unsere Datei "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

VB C#

Als nächstes werden wir unsere Richtlinien definieren. In diesem Beispiel verwenden wir eine Kombination aus Wiederholungs- und Unterbrechungsrichtlinien zur Behandlung von Fehlern:

var retryPolicy = Policy
    .Handle<Exception>()
    .WaitAndRetryAsync(3, i => TimeSpan.FromSeconds(2 * i));

var circuitBreakerPolicy = Policy
    .Handle<Exception>()
    .CircuitBreakerAsync(2, TimeSpan.FromSeconds(30));

var retryPolicy = Policy
    .Handle<Exception>()
    .WaitAndRetryAsync(3, i => TimeSpan.FromSeconds(2 * i));

var circuitBreakerPolicy = Policy
    .Handle<Exception>()
    .CircuitBreakerAsync(2, TimeSpan.FromSeconds(30));

Dim retryPolicy = Policy.Handle(Of Exception)().WaitAndRetryAsync(3, Function(i) TimeSpan.FromSeconds(2 * i))

Dim circuitBreakerPolicy = Policy.Handle(Of Exception)().CircuitBreakerAsync(2, TimeSpan.FromSeconds(30))

VB C#

Mit der "RetryPolicy" wird die fehlgeschlagene Anfrage bis zu dreimal mit einer exponentiellen Backoff-Strategie wiederholt, wobei zwischen den Wiederholungen 2 Sekunden, 4 Sekunden und 8 Sekunden gewartet wird. Die "circuitBreakerPolicy" öffnet den Stromkreis, wenn innerhalb eines Zeitintervalls von 30 Sekunden zwei aufeinanderfolgende Ausfälle auftreten.

Definieren wir nun unseren IronPDF-Code, um eine URL in eine PDF-Datei zu konvertieren:

var htmlToPdf = new ChromePdfRenderer();
var pdfBytes = await retryPolicy
    .WrapAsync(circuitBreakerPolicy)
    .ExecuteAsync(() =>
    {
        Console.WriteLine("Attempting to convert URL to PDF...");
// var result
        var result = 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(() =>
    {
        Console.WriteLine("Attempting to convert URL to PDF...");
// var result
        var result = 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(Function()
		Console.WriteLine("Attempting to convert URL to PDF...")
' var result
		Dim result = htmlToPdf.RenderUrlAsPdfAsync("https://example.com")
		Console.WriteLine("Conversion successful!")
		Return result
End Function)

pdfBytes.SaveAs("output.pdf")

VB C#

Im obigen Beispielcode verpacken wir unsere retryPolicy und circuitBreakerPolicy mit der Methode WrapAsync. So können wir mehrere Richtlinien nacheinander auf neue Anfragen anwenden. Die Methode "ExecuteAsync" führt den bereitgestellten Delegaten aus, der in diesem Code die Methode "RenderUrlAsPdfAsync" von IronPDF ist.

Durch die Anwendung von Polly-Richtlinien stellen wir sicher, dass unser Code gegen transiente Fehler resistent ist. Wenn eine Anfrage fehlschlägt, wird Polly sie automatisch entsprechend der Wiederholungsrichtlinie erneut versuchen. Überschreitet die Anzahl der aufeinanderfolgenden Ausfälle den voreingestellten Schwellenwert, öffnet die Unterbrecherrichtlinie den Stromkreis und verhindert weitere Anfragen für eine bestimmte Dauer.

Testfälle für Polly Policies

Um die Wirksamkeit unserer Polly-Richtlinien zu testen, simulieren wir einige fehlgeschlagene Anfragen. Ändern Sie die URL auf einen 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}");
    }
}

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 url

VB C#

Im obigen Code durchlaufen wir 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 Meldung in der Konsole angezeigt.

.NET Core Polly (Wie es für Entwickler funktioniert): Abbildung 1 - URL zu PDF-Ausgabe

Schlussfolgerung

Polly ist eine leistungsstarke und flexible Bibliothek zur Implementierung von Resilienz und transienter Fehlerbehandlung in .NET Core-Anwendungen. Durch die Kombination von Richtlinien wie Wiederholung und Unterbrechung können Entwickler robuste und fehlertolerante Systeme aufbauen, die Ausfälle problemlos bewältigen.

In diesem Tutorial haben wir untersucht, 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 Wiederholungsversuche und Unterbrecher. Wir haben unsere Richtlinien auch mit verschiedenen URLs getestet. Wir können es auch tun für konvertierung von HTML in PDF.

IronPDF bietet eine kostenloser Testund die Lizenzen beginnen bei $749, so dass Sie die Möglichkeiten in Ihren Projekten nutzen können.

< PREVIOUS
C# Split String (Wie es funktioniert für Entwickler)

NÄCHSTES >
Blazor vs MVC (Wie es für Entwickler funktioniert)