Polly Tekrar (Geliştiriciler için Nasıl Çalışır)

Polly Yükleme

Polly'yi NuGet Paket Yöneticisi Konsolu aracılığıyla şu komutu kullanarak yükleyebilirsiniz:

Install-Package Polly

Veya .NET CLI üzerinden:

dotnet add package Polly

Polly kullanım deyimlerini ekleme

C# dosyanıza Polly isim alanını dahil edin:

using Polly;

using Polly;

Imports Polly

Üstel Geri Çekilme

Üstel geri çekilme, istekler ve yeniden denemeler arasındaki gecikmenin üstel olarak arttığı popüler bir yeniden deneme stratejisidir. Polly, WaitAndRetry() kullanarak üstel geri çekilmeyi uygulamak için uygun bir yol sağlar.

var retryPolicy = Policy
    .Handle<HttpRequestException>()
    .WaitAndRetry(
        retryCount: 3, // Max retry attempts
        sleepDurationProvider: attempt => TimeSpan.FromSeconds(Math.Pow(2, attempt)), // Exponential delay
        onRetry: (exception, timeSpan, retryCount, context) =>
        {
            Console.WriteLine($"Retry {retryCount} due to {exception.Message}");
        });

var retryPolicy = Policy
    .Handle<HttpRequestException>()
    .WaitAndRetry(
        retryCount: 3, // Max retry attempts
        sleepDurationProvider: attempt => TimeSpan.FromSeconds(Math.Pow(2, attempt)), // Exponential delay
        onRetry: (exception, timeSpan, retryCount, context) =>
        {
            Console.WriteLine($"Retry {retryCount} due to {exception.Message}");
        });

Dim retryPolicy = Policy.Handle(Of HttpRequestException)().WaitAndRetry(retryCount:= 3, sleepDurationProvider:= Function(attempt) TimeSpan.FromSeconds(Math.Pow(2, attempt)), onRetry:= Sub(exception, timeSpan, retryCount, context)
	Console.WriteLine($"Retry {retryCount} due to {exception.Message}")
End Sub)

Devre Kesici ile Yeniden Deneme

Yeniden denemeyi devre kesici ile birleştirmek, bir hizmet sürekli arızalandığında tekrar eden yeniden denemeleri önleyerek direnci daha da artırabilir. Polly, yeniden deneme ve devre kesici politikalarını kolayca birleştirmenizi sağlar.

// Define a circuit breaker policy
var circuitBreakerPolicy = Policy
    .Handle<HttpRequestException>()
    .CircuitBreaker(
        exceptionsAllowedBeforeBreaking: 3, // Number of exceptions before breaking
        durationOfBreak: TimeSpan.FromSeconds(30), // Time circuit stays open
        onBreak: (ex, breakDelay) =>
        {
            Console.WriteLine($"Circuit broken due to {ex.Message}. Retry after {breakDelay.TotalSeconds} seconds.");
        },
        onReset: () =>
        {
            Console.WriteLine("Circuit reset.");
        });

// Define a retry policy
var retryPolicy = Policy
    .Handle<HttpRequestException>()
    .WaitAndRetry(
        retryCount: 3, // Max retry attempts
        sleepDurationProvider: attempt => TimeSpan.FromSeconds(2), // Fixed retry delay
        onRetry: (exception, timeSpan, retryCount, context) =>
        {
            Console.WriteLine($"Retry {retryCount} due to {exception.Message}");
        });

// Combine both policies into a single policy wrap
var policyWrap = Policy.Wrap(circuitBreakerPolicy, retryPolicy);

// Define a circuit breaker policy
var circuitBreakerPolicy = Policy
    .Handle<HttpRequestException>()
    .CircuitBreaker(
        exceptionsAllowedBeforeBreaking: 3, // Number of exceptions before breaking
        durationOfBreak: TimeSpan.FromSeconds(30), // Time circuit stays open
        onBreak: (ex, breakDelay) =>
        {
            Console.WriteLine($"Circuit broken due to {ex.Message}. Retry after {breakDelay.TotalSeconds} seconds.");
        },
        onReset: () =>
        {
            Console.WriteLine("Circuit reset.");
        });

// Define a retry policy
var retryPolicy = Policy
    .Handle<HttpRequestException>()
    .WaitAndRetry(
        retryCount: 3, // Max retry attempts
        sleepDurationProvider: attempt => TimeSpan.FromSeconds(2), // Fixed retry delay
        onRetry: (exception, timeSpan, retryCount, context) =>
        {
            Console.WriteLine($"Retry {retryCount} due to {exception.Message}");
        });

// Combine both policies into a single policy wrap
var policyWrap = Policy.Wrap(circuitBreakerPolicy, retryPolicy);

' Define a circuit breaker policy
Dim circuitBreakerPolicy = Policy.Handle(Of HttpRequestException)().CircuitBreaker(exceptionsAllowedBeforeBreaking:= 3, durationOfBreak:= TimeSpan.FromSeconds(30), onBreak:= Sub(ex, breakDelay)
			Console.WriteLine($"Circuit broken due to {ex.Message}. Retry after {breakDelay.TotalSeconds} seconds.")
End Sub, onReset:= Sub()
			Console.WriteLine("Circuit reset.")
End Sub)

' Define a retry policy
Dim retryPolicy = Policy.Handle(Of HttpRequestException)().WaitAndRetry(retryCount:= 3, sleepDurationProvider:= Function(attempt) TimeSpan.FromSeconds(2), onRetry:= Sub(exception, timeSpan, retryCount, context)
	Console.WriteLine($"Retry {retryCount} due to {exception.Message}")
End Sub)

' Combine both policies into a single policy wrap
Dim policyWrap = Policy.Wrap(circuitBreakerPolicy, retryPolicy)

Bu örnekte:

• CircuitBreaker(), 3 istisnadan sonra kırılan ve 30 saniye açık kalan bir devre kesici politikası tanımlar.
• Policy.Wrap(), devre kesici ve yeniden deneme politikalarını tek bir politika içinde birleştirir.

IronPDF ile Polly Yeniden Deneme

IronPDF ile çalışırken, dış kaynaklardan veri fetch etmeniz veya bir PDF üretmeden önce karmaşık işlemler gerçekleştirmeniz gereken senaryolar olabilir.

Böyle durumlarda, geçici hatalar veya PDF oluşturma başarısızlıklarına yol açabilecek geçici sorunlarla karşılaşabilirsiniz. Bu geçici hataları nazikçe ele almak için, IronPDF ile birlikte Polly Yeniden Deneme'yi kullanabilirsiniz.

IronPDF ve Polly'yi Yükleme

Başlamadan önce, projenizde IronPDF NuGet paketini yüklediğinizden emin olun.

Install-Package IronPdf

IronPDF ile Polly Yeniden Deneme Kullanma

IronPDF kullanarak bir PDF oluştururken geçici hataları ele almak için Polly Yeniden Deneme'yi nasıl kullandığımız bir örneğe bakalım. Aşağıdaki örnekte, bir dış API'den veri fetch etmeyi simüle edeceğiz ve ardından bu veriye dayanarak bir PDF oluşturacağız. Başarısızlık durumunda verileri fetch etme işlemini gerçekleştirmek için Polly Retry kullanacağız.

using System;
using System.Net.Http;
using System.Threading.Tasks;
using IronPdf;
using Polly;

namespace IronPdfWithPollyRetry
{
    public class Program
    {
        public static async Task Main(string[] args)
        {
            // Define a retry policy with async capability
            var retryPolicy = Policy
                .Handle<HttpRequestException>() // Specify exception type to handle
                .WaitAndRetryAsync(
                    3, // Retry attempts
                    retryAttempt => TimeSpan.FromSeconds(2), // Calculated retry delay
                    (exception, timeSpan, retryCount, context) =>
                    {
                        Console.WriteLine("Retry " + retryCount + " due to " + exception.Message);
                    });

            // Execute the retry policy asynchronously
            var pdf = await retryPolicy.ExecuteAsync(async () =>
            {
                var data = await FetchDataFromExternalApiAsync(); // Fetch data from an external source
                return GeneratePdfFromData(data); // Generate PDF using fetched data
            });

            pdf.SaveAs("GeneratedDocument.pdf");
        }

        // Simulate fetching data from an external API
        static async Task<string> FetchDataFromExternalApiAsync()
        {
            await Task.Delay(100); // Simulate delay
            throw new HttpRequestException("Failed to fetch data from external API");
        }

        // Generate PDF using IronPDF based on the fetched data
        static PdfDocument GeneratePdfFromData(string data)
        {
            var htmlContent = "<html><body><h1>Data: " + data + "</h1></body></html>";
            var renderer = new ChromePdfRenderer();
            return renderer.RenderHtmlAsPdf(htmlContent);
        }
    }
}

using System;
using System.Net.Http;
using System.Threading.Tasks;
using IronPdf;
using Polly;

namespace IronPdfWithPollyRetry
{
    public class Program
    {
        public static async Task Main(string[] args)
        {
            // Define a retry policy with async capability
            var retryPolicy = Policy
                .Handle<HttpRequestException>() // Specify exception type to handle
                .WaitAndRetryAsync(
                    3, // Retry attempts
                    retryAttempt => TimeSpan.FromSeconds(2), // Calculated retry delay
                    (exception, timeSpan, retryCount, context) =>
                    {
                        Console.WriteLine("Retry " + retryCount + " due to " + exception.Message);
                    });

            // Execute the retry policy asynchronously
            var pdf = await retryPolicy.ExecuteAsync(async () =>
            {
                var data = await FetchDataFromExternalApiAsync(); // Fetch data from an external source
                return GeneratePdfFromData(data); // Generate PDF using fetched data
            });

            pdf.SaveAs("GeneratedDocument.pdf");
        }

        // Simulate fetching data from an external API
        static async Task<string> FetchDataFromExternalApiAsync()
        {
            await Task.Delay(100); // Simulate delay
            throw new HttpRequestException("Failed to fetch data from external API");
        }

        // Generate PDF using IronPDF based on the fetched data
        static PdfDocument GeneratePdfFromData(string data)
        {
            var htmlContent = "<html><body><h1>Data: " + data + "</h1></body></html>";
            var renderer = new ChromePdfRenderer();
            return renderer.RenderHtmlAsPdf(htmlContent);
        }
    }
}

Imports System
Imports System.Net.Http
Imports System.Threading.Tasks
Imports IronPdf
Imports Polly

Namespace IronPdfWithPollyRetry
	Public Class Program
		Public Shared Async Function Main(ByVal args() As String) As Task
			' Define a retry policy with async capability
			Dim retryPolicy = Policy.Handle(Of HttpRequestException)().WaitAndRetryAsync(3, Function(retryAttempt) TimeSpan.FromSeconds(2), Sub(exception, timeSpan, retryCount, context)
				Console.WriteLine("Retry " & retryCount & " due to " & exception.Message)
			End Sub)

			' Execute the retry policy asynchronously
			Dim pdf = Await retryPolicy.ExecuteAsync(Async Function()
				Dim data = Await FetchDataFromExternalApiAsync() ' Fetch data from an external source
				Return GeneratePdfFromData(data) ' Generate PDF using fetched data
			End Function)

			pdf.SaveAs("GeneratedDocument.pdf")
		End Function

		' Simulate fetching data from an external API
		Private Shared Async Function FetchDataFromExternalApiAsync() As Task(Of String)
			Await Task.Delay(100) ' Simulate delay
			Throw New HttpRequestException("Failed to fetch data from external API")
		End Function

		' Generate PDF using IronPDF based on the fetched data
		Private Shared Function GeneratePdfFromData(ByVal data As String) As PdfDocument
			Dim htmlContent = "<html><body><h1>Data: " & data & "</h1></body></html>"
			Dim renderer = New ChromePdfRenderer()
			Return renderer.RenderHtmlAsPdf(htmlContent)
		End Function
	End Class
End Namespace

Bu C# kodu, yeniden deneme politikalarını uygulamak için Polly kütüphanesini IronPDF ile birlikte kullanarak bir PDF belgesi oluşturmayı nasıl yapacağınızı gösterir. Main yöntemi, Polly'nin WaitAndRetryAsync yöntemi kullanılarak bir yeniden deneme politikası başlatır.

Bu politika, HttpRequestException ele alması ve ilk deneme ile yeniden denemeler arasında 2 saniye gecikme ile operasyona 3 kez kadar yeniden deneme yapması gerektiğini belirtir. Bir yeniden deneme başarısızlığı gerçekleşirse, yeniden deneme denemesi numarasını ve istisna mesajını konsolda belirten bir mesaj yazdırılır.

Main yöntemi içinde, yeniden deneme politikası mantığı retryPolicy.ExecuteAsync() kullanılarak eşzamansız olarak yürütülür. Bu yürütme içinde iki eşzamansız işlem birbirine zincirlenmiştir: FetchDataFromExternalApiAsync() ve GeneratePdfFromData(data).

Eğer FetchDataFromExternalApiAsync() başarısız olursa (sadece simüle edilen bir istisna ile başlatıldığı için), yeniden deneme politikası HttpRequestException yakalayacak, yeniden deneme girişimini kaydedecek ve operasyonu yeniden deneyecektir.

FetchDataFromExternalApiAsync() yöntemi, harici bir API'den veri fetch etme işlemini bir gecikme ile simüle eder ve başarısız istekleri simüle etmek için kasıtlı olarak bir HttpRequestException fırlatır.