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

Polly Kurulumu

NuGet Paket Yöneticisi Konsolu aracılığıyla Polly'yi aşağıdaki komutla kurabilirsiniz:

Install-Package Polly

.NET CLI üzerinden:

dotnet add package Polly

Polly'i kullanma deyimleri eklemek

C# dosyanıza Polly ad alanını ekleyin:

using Polly;

using Polly;

Imports Polly

Üstel Bekleme

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

Elektrik Devresiyle Yeniden Deneme

Yeniden denemeyi bir devre kesici ile birleştirmek, servis sürekli başarısız olduğunda tekrarlanan denemeleri önleyerek direnci daha da artırabilir. Polly, yeniden deneme ve devre kesici politikalarını kolayca birleştirmenize izin verir.

// 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ını tanımlar.
• Policy.Wrap(), devre kesici ve yeniden deneme politikalarını tek bir politika olarak birleştirir.

IronPDF ile Polly Yeniden Deneme

IronPDF ile çalışırken, bazen PDF oluşturmadan önce dış kaynaklardan veri almanız veya karmaşık işlemler yapmanız gerekebilir.

Bu tür durumlarda, geçici hatalar veya geçici sorunlar ile karşılaşabilir, bu da PDF oluşturma hatalarına yol açabilir. Bu geçici hataları zarifçe ele almak için, IronPDF ile birlikte Polly Yeniden Denemeyi kullanabilirsiniz.

IronPDF ve Polly Kurulumu

Başlamadan önce, projenizde IronPDF NuGet paketini kurduğunuzdan emin olun.

Install-Package IronPdf

IronPDF ile Polly Yeniden Denemeyi Kullanmak

IronPDF kullanarak PDF oluştururken geçici hataları ele almak için Polly Yeniden Denemesini nasıl kullanacağımız üzerine bir örneğe bakalım. Aşağıdaki örnekte, bir dış API'den veri almayı ve ardından bu verilere dayalı olarak PDF oluşturmayı simüle edeceğiz. Başarısızlık durumunda veri alma operasyonunu gerçekleştirmek için Polly Retry kullanılacaktır.

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, IronPDF ile bir PDF belgesi oluşturma için yeniden deneme politikalarını uygulamak üzere Polly kütüphanesini nasıl kullanacağınızı göstermektedir. Main yöntemi, Polly'nin WaitAndRetryAsync yöntemini kullanarak bir yeniden deneme politikasını başlatır.

Bu politika, HttpRequestException adresini ele alması ve başlangıç denemesi ile denemeler arasında 2 saniye gecikme ile işlemi 3 kereye kadar tekrar denemesi gerektiğini belirtir. Bir yeniden deneme hatası meydana gelirse, konsola bir mesaj yazılır ve yeniden deneme numarası ve istisna mesajı belirtilir.

Main yöntemi içinde, yeniden deneme politikası mantığı retryPolicy.ExecuteAsync() kullanılarak asenkron olarak icra edilir. Bu icra sırasında, iki asenkron operasyon birlikte zincirlenir: FetchDataFromExternalApiAsync() ve GeneratePdfFromData(data).

Eğer FetchDataFromExternalApiAsync() başarısız olursa (simüle edilmiş bir istisna ile kasıtlı olarak ayarlandığı gibi), yeniden deneme politikası HttpRequestException yakalayacak, yeniden deneme girişimini kaydedecek ve işlemi tekrar deneyecektir.

FetchDataFromExternalApiAsync() yöntemi, bir dış API'dan veri almayı simüle eder ve kasıtlı olarak başarısız istekleri simüle etmek için HttpRequestException atar.