Polly in .NET Core: A Guide to Resilience and Fault Handling

Polly is a .NET library that provides a framework for handling transient faults in an application. It allows developers to implement retry policies, circuit breakers, timeouts, and other fault-handling patterns in a clean, composable, and declarative way. In this post, we'll explore what Polly is, why it’s valuable, and how to use it in .NET Core applications to build resilient, fault-tolerant solutions.

What is Polly?

Polly is an open-source library that enables you to build fault-handling and resilience logic into your applications. It helps you manage faults and unexpected scenarios by providing a range of resilience policies. Polly works seamlessly with .NET Core and can be used across HTTP clients, database calls, message queues, and more. Here are the key policies Polly supports:

• Retry: Retry a failed operation multiple times before giving up.
• Circuit Breaker: Stop calling a failing service temporarily to give it time to recover.
• Timeout: Fail if an operation takes longer than a specified time.
• Fallback: Provide an alternative response or behavior when an operation fails.
• Bulkhead Isolation: Limit concurrent executions to avoid resource exhaustion.
• Cache: Cache responses to avoid repeated calls for the same result.

By combining these policies, Polly enables you to create robust and customizable resilience strategies tailored to your application’s needs.

Why Use Polly?

In any distributed application, you’ll inevitably encounter issues like network instability, service unavailability, or rate limiting. Polly allows you to handle these scenarios without excessive code and helps:

• Improve User Experience: Users will experience fewer errors and smoother interactions if transient faults are handled gracefully.
• Enhance Reliability: Redundant attempts (like retries) increase the likelihood of success when services experience intermittent failures.
• Manage System Load: Circuit breakers and bulkhead isolation help to prevent overwhelming dependent services and your application.

By using Polly in .NET Core applications, you get a consistent and reliable way to manage resilience, even as your system scales and complexity grows.

Getting Started with Polly in .NET Core

To get started, install Polly through NuGet:

dotnet add package Polly

Polly integrates well with the HttpClientFactory in .NET Core, which simplifies managing HTTP requests and supports resilient communication between services. Here’s a look at how to apply Polly with HttpClientFactory.

Example: Using Polly with HttpClientFactory in .NET Core

The IHttpClientFactory offers a way to register and configure HttpClient instances, and it easily integrates Polly policies for fault tolerance.

1. Define Resilience Policies: Set up retry and circuit breaker policies.
2. Configure HttpClient: Apply these policies to HttpClient.

Step 1: Define Resilience Policies

In your Startup.cs or Program.cs (for minimal APIs), configure Polly policies:

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

// Retry policy for transient errors
var retryPolicy = HttpPolicyExtensions
    .HandleTransientHttpError() // Handles 5xx errors and network failures
    .OrResult(msg => msg.StatusCode == HttpStatusCode.TooManyRequests) // Additional handling for 429
    .WaitAndRetryAsync(3, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)));

// Circuit breaker policy to prevent hammering a failing service
var circuitBreakerPolicy = HttpPolicyExtensions
    .HandleTransientHttpError()
    .CircuitBreakerAsync(2, TimeSpan.FromSeconds(30));

These policies set up a retry mechanism with exponential backoff and a circuit breaker to stop calls when repeated failures are detected.

Step 2: Configure HttpClient with Polly Policies

Register HttpClient in the dependency injection container, applying the Polly policies:

services.AddHttpClient("MyResilientClient", client =>
{
    client.BaseAddress = new Uri("https://example.api.com/");
})
.AddPolicyHandler(retryPolicy)
.AddPolicyHandler(circuitBreakerPolicy);

Now, when MyResilientClient is injected into services or controllers, it will automatically use the defined retry and circuit breaker policies.

Step 3: Use the Configured HttpClient

Inject and use the configured HttpClient with the resilience policies:

public class MyService
{
    private readonly HttpClient _httpClient;

    public MyService(IHttpClientFactory httpClientFactory)
    {
        _httpClient = httpClientFactory.CreateClient("MyResilientClient");
    }

    public async Task<string> GetDataAsync()
    {
        var response = await _httpClient.GetAsync("/data");
        response.EnsureSuccessStatusCode();
        return await response.Content.ReadAsStringAsync();
    }
}

With this setup, GetDataAsync will retry failed requests automatically up to three times and break the circuit if there are multiple failures within a short timeframe.

Conclusion

Polly in .NET Core is a powerful tool for building resilient and fault-tolerant applications. By using Polly’s declarative syntax, you can easily create custom resilience policies like retries, circuit breakers, and timeouts.

Find out more about Polly- Meet Polly: The .NET resilience library

Happy coding!! 😊