🔄 Retry Policies in .NET Core

📖 What are Retry Policies?

A Retry Policy is a resilience strategy used in distributed systems to handle transient failures (temporary issues such as network hiccups, timeouts, or overloaded services). Instead of failing immediately, the system retries the operation after a delay, often with strategies like exponential backoff and jitter.

🛠 Example in .NET Core (using Polly)

Here’s how to configure an HTTP client with retries and exponential backoff:

// Install-Package Polly.Extensions.Http

using Microsoft.Extensions.DependencyInjection;
using Polly;
using Polly.Extensions.Http;
using System;
using System.Net.Http;

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddHttpClient("RetryClient")
            .AddPolicyHandler(GetRetryPolicy());
    }

    private IAsyncPolicy<HttpResponseMessage> GetRetryPolicy()
    {
        return HttpPolicyExtensions
            .HandleTransientHttpError()
            .WaitAndRetryAsync(
                retryCount: 3,
                sleepDurationProvider: attempt => TimeSpan.FromSeconds(Math.Pow(2, attempt)) + 
                                                  TimeSpan.FromMilliseconds(new Random().Next(0, 100)),
                onRetry: (outcome, timespan, retryAttempt, context) =>
                {
                    Console.WriteLine($"Retry {retryAttempt} after {timespan.TotalSeconds} seconds");
                });
    }
}
    

✅ Advantages

• Improves resilience against transient failures.
• Reduces downtime by automatically retrying failed operations.
• Supports advanced strategies (exponential backoff, jitter).
• Integrates easily with HttpClientFactory in .NET Core.

⚠️ Disadvantages

• Can increase latency if retries are frequent.
• May overload downstream services if not tuned properly.
• Not suitable for permanent failures (e.g., invalid credentials).
• Requires careful configuration to avoid retry storms.

🧭 Best Practices

• Use exponential backoff with jitter to avoid thundering herd problems.
• Limit the maximum number of retries.
• Combine with circuit breakers to prevent retrying when a service is down.
• Log retry attempts for observability.
• Apply retries only to idempotent operations (safe to repeat).

🔒 Precautions

• Do not retry on client errors (e.g., 400 Bad Request, 401 Unauthorized).
• Secure sensitive operations — retries should not duplicate payments or irreversible actions.
• Monitor retry metrics to detect hidden issues.
• Test under load to ensure retries don’t worsen failures.

🎯 Summary

Retry Policies are essential for building resilient microservices. In .NET Core, libraries like Polly make it easy to implement retries with exponential backoff and jitter. When combined with circuit breakers and proper monitoring, they significantly improve system reliability.