Polly pour C# (.NET) : guide complet avec exemples

Qu'est-ce que Polly et pourquoi l'utiliser ?

Polly est une bibliothèque puissante et flexible pour .NET (C#, F#, VB.NET) conçue pour gérer les défaillances temporaires et améliorer la résilience des applications. Elle implémente des modèles de robustesse tels que les tentatives (Retry), le coupe-circuit (Circuit Breaker), les délais d'attente (Timeout), l'isolation par cloisonnement (Bulkhead Isolation) et la mise en cache (Cache).

Dans le monde moderne de l'architecture microservices et du cloud computing, les applications interagissent constamment avec des ressources externes : bases de données, services web, API. Ces interactions peuvent être peu fiables — erreurs réseau, indisponibilité temporaire d'un service, dépassement des limites de requêtes. Polly permet de gérer ces situations avec élégance, sans écrire de code lourd avec des blocs try-catch.

Les principaux cas d'utilisation :

• Retry (Tentatives) : Réessayer automatiquement une opération en cas d'erreur temporaire.
• Circuit Breaker (Coupe-circuit) : Cesser les tentatives d'appel si le service génère constamment des erreurs, afin de lui laisser le temps de récupérer.
• Timeout (Délai d'attente) : Limiter le temps d'exécution d'une opération.
• Bulkhead (Cloisonnement) : Limiter le nombre d'opérations parallèles pour qu'une opération "défaillante" ne bloque pas tout le pool de threads.
• Cache (Mise en cache) : Mettre en cache les résultats des opérations réussies.
• Fallback (Solution de repli) : Exécuter une action alternative en cas d'échec.

Installation de Polly

Polly est distribuée via NuGet, le gestionnaire de paquets pour .NET. Vous pouvez l'installer de plusieurs manières :

Via la console du gestionnaire de paquets (Visual Studio)

Install-Package Polly

Via l'interface CLI .NET

dotnet add package Polly

Via PackageReference (dans le fichier .csproj)

<PackageReference Include="Polly" Version="8.2.0" />

Après l'installation, ajoutez les directives using dans votre code :

using Polly;
using Polly.Retry;
using Polly.CircuitBreaker;
using Polly.Timeout;
using Polly.Bulkhead;
using Polly.Caching;
using Polly.Fallback;
using Polly.Wrap;

Démarrage rapide avec un exemple de code

Prenons un exemple simple : nous avons une méthode qui appelle une API externe, et nous voulons réessayer l'appel 3 fois en cas d'exception.

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

public class ApiClient
{
    private readonly HttpClient _httpClient;
    private readonly AsyncRetryPolicy _retryPolicy;

    public ApiClient()
    {
        _httpClient = new HttpClient();
        
        // Création de la politique de tentatives
        _retryPolicy = Policy
            .Handle<HttpRequestException>() // Quelles exceptions gérer
            .Or<TimeoutException>()          // Ou délai d'attente
            .WaitAndRetryAsync(
                3,                           // Nombre de tentatives
                retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), // Délai exponentiel
                onRetry: (exception, timeSpan, retryCount, context) =>
                {
                    Console.WriteLine($"Tentative {retryCount} échouée. Nouvel essai dans {timeSpan.Seconds} sec. Erreur : {exception.Message}");
                }
            );
    }

    public async Task<string> GetDataAsync(string url)
    {
        // Exécution de la requête avec la politique
        return await _retryPolicy.ExecuteAsync(async () =>
        {
            var response = await _httpClient.GetAsync(url);
            response.EnsureSuccessStatusCode();
            return await response.Content.ReadAsStringAsync();
        });
    }
}

// Utilisation
public class Program
{
    public static async Task Main()
    {
        var client = new ApiClient();
        try
        {