Client HTTP en C# : techniques avancées pour travailler avec les requêtes

Client HTTP en C# : faire des requêtes correctement — niveau avancé

Dans le développement .NET moderne, travailler avec les requêtes HTTP va bien au-delà d’un simple appel à WebClient ou au HttpClient de base. Au niveau avancé, il est nécessaire de prendre en compte la gestion du pool de connexions, la gestion correcte des erreurs, les timeouts, les politiques de tentatives et l’exécution asynchrone. Dans cet article, nous allons passer en revue les meilleures pratiques pour travailler avec le client HTTP en C#, qui vous aideront à créer des applications fiables et performantes.

1. Utilisation correcte de HttpClient et du pool de connexions

L’une des erreurs les plus fréquentes est de créer une nouvelle instance de HttpClient pour chaque requête. Cela entraîne un épuisement des sockets (socket exhaustion) car chaque instance maintient une connexion TCP ouverte dans l’état TIME_WAIT.

Incorrect :

public async Task<string> GetDataAsync(string url){    using (var client = new HttpClient())    {        return await client.GetStringAsync(url);    }}

Correct : utilisez une seule instance statique ou singleton de HttpClient.

public class HttpService{    private static readonly HttpClient _client = new HttpClient();

    public async Task<string> GetDataAsync(string url)    {        return await _client.GetStringAsync(url);    }}

Pour un contrôle plus fin, utilisez IHttpClientFactory du package Microsoft.Extensions.Http. La fabrique gère le pool et restaure automatiquement les connexions en cas de panne DNS.

// Dans Startup.cs ou Program.csservices.AddHttpClient("MyClient", client =>{    client.BaseAddress = new Uri("https://api.example.com");    client.DefaultRequestHeaders.Add("User-Agent", "MyApp/1.0");});

// Dans le servicepublic class MyService{    private readonly IHttpClientFactory _httpClientFactory;

    public MyService(IHttpClientFactory httpClientFactory)    {        _httpClientFactory = httpClientFactory;    }

    public async Task<string> GetDataAsync()    {        var client = _httpClientFactory.CreateClient("MyClient");        return await client.GetStringAsync("/data");    }}

2. Timeouts et annulation des requêtes

Sans timeouts, votre client peut rester bloqué indéfiniment. Dans HttpClient, il existe deux mécanismes :

• Timeout — un timeout général pour toute la requête.
• CancellationToken — pour annuler la requête depuis l’extérieur (par exemple, l’utilisateur a fermé l’application).

Définissez Timeout de manière raisonnable. Pour la plupart des API, 10 à 30 secondes conviennent.

var client = new HttpClient{    Timeout = TimeSpan.FromSeconds(15)};

// Exemple avec CancellationTokenSourceusing var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));try{    var response = await client.GetAsync("https://slow-api.example.com", cts.Token);}catch (TaskCanceledException){    Console.WriteLine("Requête annulée pour cause de timeout.");}

Important : Timeout et CancellationToken fonctionnent ensemble. Si le CancellationToken se déclenche plus tôt, la requête est annulée plus rapidement.

3. Gestion des erreurs et politique de tentatives (Retry)

Les pannes réseau et les erreurs temporaires du serveur sont courantes. Au lieu d’échouer immédiatement, implémentez une politique de tentatives avec un délai exponentiel. La bibliothèque Polly est parfaite pour cela.

using Polly;using Polly.Extensions.Http;

// Définir la politique de tentativesvar retryPolicy = HttpPolicyExtensions    .HandleTransientHttpError() // 5xx, 408    .Or<HttpRequestException>()    .WaitAndRetryAsync(3, retryAttempt =>        Tim