.NET  

How to Implement Polly Retry Policy in .NET for Transient Fault Handling

Introduction

When building modern .NET applications, especially microservices or APIs that depend on external services (like APIs, databases, or third-party systems), failures are very common. These failures are often temporary, such as network issues, timeouts, or service overload. These are called transient faults.

Instead of failing immediately, a smart application should retry the operation after a short delay. This improves reliability and user experience.

This is where Polly comes in. Polly is a powerful .NET resilience and transient-fault-handling library that helps you implement retry policies, circuit breakers, timeouts, and more.

In this article, we will learn how to implement a Polly retry policy in .NET step by step using simple language and practical examples.

What is Polly in .NET?

Polly is a .NET library that allows developers to handle failures gracefully. It provides different resilience strategies like:

  • Retry

  • Circuit Breaker

  • Timeout

  • Fallback

For this article, we will focus on the Retry Policy, which is the most commonly used feature.

What is a Retry Policy?

A retry policy means trying the same operation again if it fails due to a temporary issue.

For example:

  • API call fails due to network issue → retry

  • Database connection times out → retry

  • External service returns error → retry

Instead of showing an error immediately, the system retries automatically.

Why Use Polly Retry Policy?

Using Polly retry policy in .NET applications provides many benefits:

  • Improves application reliability

  • Handles temporary failures automatically

  • Reduces manual error handling code

  • Enhances user experience

  • Works well in microservices architecture

Step 1: Install Polly Package

First, you need to install the Polly NuGet package.

dotnet add package Polly

Or using Package Manager:

Install-Package Polly

Step 2: Create a Simple Retry Policy

Now let’s create a basic retry policy.

using Polly;

var retryPolicy = Policy
    .Handle<Exception>()
    .Retry(3);

Explanation:

  • Handle() → retry for any exception

  • Retry(3) → retry 3 times if it fails

Step 3: Execute Code with Retry Policy

Now use the retry policy to execute your code.

retryPolicy.Execute(() =>
{
    Console.WriteLine("Trying operation...");
    throw new Exception("Temporary failure");
});

This will retry the operation 3 times before finally throwing an exception.

Step 4: Add Wait Time Between Retries

Retrying immediately is not always good. It’s better to wait before retrying.

var retryPolicy = Policy
    .Handle<Exception>()
    .WaitAndRetry(3, retryAttempt => TimeSpan.FromSeconds(2));

Explanation:

  • WaitAndRetry → waits before retrying

  • 3 → number of retries

  • TimeSpan → delay between retries

Step 5: Use Exponential Backoff (Best Practice)

Exponential backoff increases delay after each retry.

var retryPolicy = Policy
    .Handle<Exception>()
    .WaitAndRetry(3, retryAttempt =>
        TimeSpan.FromSeconds(Math.Pow(2, retryAttempt))
    );

Example delays:

  • 1st retry → 2 seconds

  • 2nd retry → 4 seconds

  • 3rd retry → 8 seconds

This reduces load on the system.

Step 6: Logging Retry Attempts

You can log each retry attempt.

var retryPolicy = Policy
    .Handle<Exception>()
    .WaitAndRetry(3,
        retryAttempt => TimeSpan.FromSeconds(2),
        (exception, timeSpan, retryCount, context) =>
        {
            Console.WriteLine($"Retry {retryCount} after {timeSpan.TotalSeconds}s due to {exception.Message}");
        });

This helps in debugging and monitoring.

Step 7: Using Polly with HttpClient (Real-World Example)

In ASP.NET Core, Polly is commonly used with HttpClient.

builder.Services.AddHttpClient("MyClient")
    .AddPolicyHandler(Policy
        .Handle<HttpRequestException>()
        .WaitAndRetryAsync(3, retryAttempt =>
            TimeSpan.FromSeconds(2)));

Now every HTTP call using this client will automatically retry.

Step 8: Handling Specific Exceptions

You should not retry all exceptions. Handle only specific ones.

var retryPolicy = Policy
    .Handle<HttpRequestException>()
    .Or<TimeoutException>()
    .Retry(3);

This avoids unnecessary retries.

Step 9: Async Retry Policy

For async code, use async version.

var retryPolicy = Policy
    .Handle<HttpRequestException>()
    .WaitAndRetryAsync(3, retryAttempt => TimeSpan.FromSeconds(2));

await retryPolicy.ExecuteAsync(async () =>
{
    await Task.Delay(100);
    throw new HttpRequestException("Temporary API failure");
});

Best Practices for Polly Retry Policy

  • Use exponential backoff for better performance

  • Retry only transient faults

  • Avoid infinite retries

  • Combine with circuit breaker for better resilience

  • Log retry attempts for monitoring

Common Mistakes to Avoid

  • Retrying permanent failures

  • Too many retries causing delays

  • No logging for retries

  • Using retry without delay

Real-World Use Cases

  • Calling external APIs

  • Database connection retries

  • Microservices communication

  • Cloud-based applications

Summary

Polly retry policy in .NET is a powerful way to handle transient faults and improve application reliability. By retrying failed operations with proper delay and strategy, you can make your applications more resilient and user-friendly. Using features like WaitAndRetry, exponential backoff, and HttpClient integration, Polly helps you build production-ready .NET applications with minimal effort.

Membership not found