Consommer une API REST en C# : HttpClient et JSON

private static readonly HttpClient Http = new()
{
    BaseAddress = new Uri("https://api.gsb.example/v1/"),
    Timeout = TimeSpan.FromSeconds(10),
};

[
  { "code": "PARA1000", "nom": "Paracétamol", "dosage": "1000 mg", "surOrdonnance": false },
  { "code": "AMOX500", "nom": "Amoxicilline", "dosage": "500 mg", "surOrdonnance": true }
]

public record MedicamentDto(string Code, string Nom, string? Dosage, bool SurOrdonnance);

using System.Net;
using System.Net.Http.Headers;
using System.Net.Http.Json;

namespace Gsb.Donnees;

public record ProblemeApi(string? Title, int Status, string? Detail);

public class ApiException(string message) : Exception(message);

public class MedicamentApi
{
    private readonly HttpClient _http;

    public MedicamentApi(HttpClient http, string jeton)
    {
        _http = http;
        _http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", jeton);
    }

    public async Task<List<MedicamentDto>> RechercherAsync(string nom, CancellationToken annulation = default)
    {
        string url = $"medicaments?nom={Uri.EscapeDataString(nom)}";
        using HttpResponseMessage reponse = await _http.GetAsync(url, annulation);

        if (reponse.StatusCode == HttpStatusCode.Unauthorized)
            throw new ApiException("Session expirée : reconnecte-toi.");
        if (!reponse.IsSuccessStatusCode)
        {
            ProblemeApi? probleme = await LireProblemeAsync(reponse, annulation);
            throw new ApiException(probleme?.Detail ?? $"Erreur {(int)reponse.StatusCode} de l'API.");
        }

        return await reponse.Content.ReadFromJsonAsync<List<MedicamentDto>>(annulation) ?? [];
    }

    private static async Task<ProblemeApi?> LireProblemeAsync(HttpResponseMessage reponse, CancellationToken annulation)
    {
        try { return await reponse.Content.ReadFromJsonAsync<ProblemeApi>(annulation); }
        catch (System.Text.Json.JsonException) { return null; }   // corps vide ou pas en JSON
        catch (NotSupportedException) { return null; }            // type de contenu non JSON
    }
}

public async Task<MedicamentDto> AjouterAsync(MedicamentDto medicament, CancellationToken annulation = default)
{
    using HttpResponseMessage reponse = await _http.PostAsJsonAsync("medicaments", medicament, annulation);
    if (reponse.StatusCode != HttpStatusCode.Created)
    {
        ProblemeApi? probleme = await LireProblemeAsync(reponse, annulation);
        throw new ApiException(probleme?.Detail ?? $"Erreur {(int)reponse.StatusCode} de l'API.");
    }
    return (await reponse.Content.ReadFromJsonAsync<MedicamentDto>(annulation))!;
}

public async Task ModifierAsync(MedicamentDto medicament, CancellationToken annulation = default)
{
    string url = $"medicaments/{Uri.EscapeDataString(medicament.Code)}";
    using HttpResponseMessage reponse = await _http.PutAsJsonAsync(url, medicament, annulation);
    if (reponse.StatusCode == HttpStatusCode.NotFound)
        throw new ApiException($"Le médicament {medicament.Code} n'existe pas.");
    reponse.EnsureSuccessStatusCode();
}

public async Task SupprimerAsync(string code, CancellationToken annulation = default)
{
    using HttpResponseMessage reponse = await _http.DeleteAsync($"medicaments/{Uri.EscapeDataString(code)}", annulation);
    if (reponse.StatusCode == HttpStatusCode.NotFound) return;   // déjà supprimé : le résultat voulu est atteint
    reponse.EnsureSuccessStatusCode();
}

private async void FrmOrdonnance_Load(object? sender, EventArgs e)
{
    try
    {
        List<MedicamentDto> medicaments = await _api.RechercherAsync("");
        cboMedicament.DisplayMember = nameof(MedicamentDto.Nom);
        cboMedicament.ValueMember = nameof(MedicamentDto.Code);
        cboMedicament.DataSource = medicaments;
    }
    catch (Exception ex) when (ex is ApiException or HttpRequestException or TaskCanceledException)
    {
        cboMedicament.Enabled = false;
        lblStatut.Text = "Référentiel des médicaments indisponible : réessaie plus tard.";
    }
}

public partial class FrmMedicaments : Form
{
    private static readonly HttpClient Http = new()
    {
        BaseAddress = new Uri("https://api.gsb.example/v1/"),
        Timeout = TimeSpan.FromSeconds(10),
    };

    private readonly MedicamentApi _api;
    private CancellationTokenSource? _annulation;

    public FrmMedicaments(string jeton)
    {
        InitializeComponent();
        _api = new MedicamentApi(Http, jeton);
    }

    private async void btnRechercher_Click(object? sender, EventArgs e)
    {
        _annulation?.Cancel();
        _annulation = new CancellationTokenSource();
        btnRechercher.Enabled = false;
        btnAnnuler.Enabled = true;
        lblStatut.Text = "Recherche en cours…";
        try
        {
            List<MedicamentDto> resultats = await _api.RechercherAsync(txtNom.Text.Trim(), _annulation.Token);
            dgvMedicaments.DataSource = resultats;
            lblStatut.Text = $"{resultats.Count} médicament(s)";
        }
        catch (OperationCanceledException) when (_annulation.IsCancellationRequested)
        {
            lblStatut.Text = "Recherche annulée.";
        }
        catch (TaskCanceledException)
        {
            lblStatut.Text = "L'API ne répond pas (délai dépassé).";
        }
        catch (ApiException ex)
        {
            lblStatut.Text = ex.Message;
        }
        catch (HttpRequestException ex)
        {
            lblStatut.Text = $"Serveur injoignable : {ex.Message}";
        }
        finally
        {
            btnRechercher.Enabled = true;
            btnAnnuler.Enabled = false;
        }
    }

    private void btnAnnuler_Click(object? sender, EventArgs e) => _annulation?.Cancel();
}