.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 Verarbeitung mehrerer gleichzeitiger Anfragen mit erfolgreichen Antworten.

In diesem Tutorial werden weitere Einzelheiten über die .NET-Bibliothek Polly zur Behandlung transienter Fehler und deren Verwendung mitIronPDF in einer ASP.NET Core-Anwendung. Wir tauchen tief in jeden Aspekt von Polly ein, erklären die Mechanik des Circuit-Breaker-Patterns, erörtern Bulkhead-Isolation und Timeouts und zeigen, wie man bestimmte Ausnahmen oder fehlgeschlagene Dienste mit Fehlerantworten auf kontrollierte, thread-sichere Weise behandelt.

Polly Policies

Transiente Fehler treten häufig auf, wenn Ihre Anwendung versucht, über eine HTTP-Anfrage eine Verbindung zu einem Webdienst, einer Datenbank oder anderen externen Ressourcen 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, indem es verschiedene Strategien anwendet und Richtlinien wie Retry Policy, erweiterte Circuit Breaker Policy, Timeout Policy, Fallback Policy und Bulkhead Isolation Policy formuliert.

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

Mit der Circuit-Breaker-Richtlinie kann Ihr System ein Abbruch-Token für den Versuch eines bestimmten Dienstes nach einer vorkonfigurierten Anzahl fehlgeschlagener Anfragen unterstützen. 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

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 beibehalten 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 Datenverkehr zulässt, um den Zustand des jeweiligen Dienstes zu überprüfen. Wenn diese Anfragen erfolgreich sind und keine Fehler auftreten, wird der Stromkreis geschlossen; andernfalls öffnet sie sich wieder.

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
:ProductInstall Install-Package IronPdf

Verwendung von Polly mit IronPDF Konvertieren einer URL in PDF

Ein herausragendes Merkmal von IronPDF ist seineHTML zu PDF Fähigkeitdabei müssen Layouts und Stile intakt bleiben. 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, umeine 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 = 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 = 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...")
		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}");
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
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ürkonvertierung von HTML in PDF.

IronPDF bietet einekostenloser Testdie Kosten für die Übersetzung und die Lizenzen beginnen zu einem wettbewerbsfähigen Preis, so dass Sie die Möglichkeiten dieser Software 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)

Sind Sie bereit, loszulegen? Version: 2024.12 gerade veröffentlicht

Gratis NuGet-Download Downloads insgesamt: 11,810,873 Lizenzen anzeigen >