Comment utiliser Refit pour consommer des API dans ASP.NET Core

Refit est une bibliothèque open source pour .NET, .NET Core et Xamarin qui simplifie et facilite la consommation des API REST en vous permettant de définir les points de terminaison de l'API en tant qu'interfaces C#, éliminant ainsi le besoin de créer des requêtes HTTP et d'analyser les réponses HTTP manuellement.

Dans cet article, nous allons nous pencher sur la bibliothèque Refit pour .NET et voir de première main comment elle simplifie le développement d'API. Pour utiliser les exemples de code fournis dans cet article, vous devez avoir installé Visual Studio 2022 sur votre système. Si vous n'en avez pas encore une copie, vous pouvez télécharger Visual Studio 2022 ici.

Dans les sections ci-dessous, nous allons implémenter deux applications, une API de contact et une application cliente pour consommer l'API de contact. L'application API de contact comprendra les types suivants :

• Contact : Ceci représente la classe modèle.
• IContactRepository : Ceci représente l'interface du référentiel de contacts.
• ContactRepository : cela représente la classe de référentiel de contacts qui contient des méthodes pour renvoyer des données de contact.
• ContactsController : cela représente le contrôleur d'API utilisé pour exposer les points de terminaison de l'API de contact aux clients API.

L'application cliente utilisera Refit pour consommer l'API de contact et afficher les enregistrements récupérés dans la fenêtre de la console.

Qu'est-ce que Refit ? Pourquoi est-ce utile ?

Refit est une bibliothèque REST rapide et sécurisée pour .NET, .NET Core et Xamarin qui transforme votre API REST en interface, facilitant ainsi la consommation de services Web RESTful. Refit transforme automatiquement les appels HTTP en interfaces C# à l'aide d'attributs pour décrire les opérations REST, simplifiant ainsi le processus de connexion aux API à l'aide d'un code minimal.

Pour utiliser des API à l'aide de Refit, vous avez besoin d'une interface capable d'interagir avec votre API. Refit agit comme un wrapper autour des méthodes de cette interface et gère les requêtes et réponses HTTP avec élégance. Refit génère automatiquement le code standard requis pour vous permettre d'accéder à vos API.

Si vous utilisez Refit pour la première fois, vous devez d'abord configurer l'instance du client HTTP en spécifiant l'adresse de base, les en-têtes HTTP, les informations de sérialisation et de désérialisation, etc. L'extrait de code suivant montre comment nous pouvons configurer l'instance du client HTTP pour se connecter à un point de terminaison dans ASP.NET Core.

string baseAddress = "http://localhost:59904/";
HttpClient _client = new HttpClient();
_client.BaseAddress = new Uri($"{BaseUrl}");
_client.DefaultRequestHeaders.Accept.Clear();
_client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
string url = BaseUrl + "api/authors";
var response = await _client.GetAuthors(url);
if (response.IsSuccessStatusCode)
{ 
    var result = await response.Content.ReadAsStringAsync();
    var data = JsonSerializer.Deserialize>(result);
}

Si vous utilisez déjà Refit, vous n'avez pas besoin de vous soucier du code standard, car Refit peut gérer toutes ces tâches avec seulement quelques lignes de code C#.

string baseAddress = "http://localhost:59904/";
var endpoint = RestService.For(baseAddress);
var contacts = await endpoint.GetAuthors();

Comme vous pouvez le voir dans les extraits de code précédents, Refit peut nous faire gagner beaucoup de temps et d’efforts en éliminant le besoin d’écrire le code standard.

Dans les sections suivantes, nous allons implémenter une API Web simple dans ASP.NET Core. Après avoir créé notre API, nous allons implémenter un client Refit pour l'utiliser.

Créer un projet d'API Web ASP.NET Core dans Visual Studio 2022

Pour créer un projet API Web ASP.NET Core 8 dans Visual Studio 2022, suivez les étapes décrites ci-dessous.

1. Lancez l’IDE ​​Visual Studio 2022.
2. Cliquez sur « Créer un nouveau projet ».
3. Dans la fenêtre « Créer un nouveau projet », sélectionnez « ASP.NET Core Web API » dans la liste des modèles affichés.
4. Cliquez sur Suivant.
5. Dans la fenêtre « Configurer votre nouveau projet », indiquez le nom et l’emplacement du nouveau projet. Cochez éventuellement la case « Placer la solution et le projet dans le même répertoire », selon vos préférences.
6. Cliquez sur Suivant.
7. Dans la fenêtre « Informations supplémentaires » affichée ci-dessous, sélectionnez « .NET 8.0 (Long Term Support) » comme version du framework et assurez-vous que la case « Utiliser les contrôleurs » est cochée. Nous utiliserons des contrôleurs dans ce projet.
8. Dans la fenêtre « Informations supplémentaires », laissez le « Type d'authentification » défini sur « Aucun » (valeur par défaut) et assurez-vous que les cases à cocher « Activer la prise en charge d'Open API », « Configurer pour HTTPS » et « Activer Docker » restent décochées. Nous n'utiliserons aucune de ces fonctionnalités ici.
9. Cliquez sur Créer.

Nous utiliserons ce projet API Web ASP.NET Core pour créer notre API dans les sections ci-dessous.

Créer la classe de modèle Contact

Créez une nouvelle classe nommée Contact dans le projet API Web que vous venez de créer et entrez le code ci-dessous.

namespace Refit_Demo
{
    public class Contact
    {
        public int Id { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public string Address { get; set; }
        public string Phone { get; set; }
    }
}

Nous utiliserons la classe Contact dans la section suivante pour travailler avec les données.

Créer la classe ContactRepository

Ensuite, nous allons créer une classe de référentiel pour travailler avec les données de contact. Par souci de simplicité et de concision, nous allons stocker nos données dans une liste en mémoire. Vous pouvez modifier cette implémentation pour stocker les données dans une base de données selon vos besoins. La classe ContactRepository implémente IContactRepository. Cette interface contient la déclaration de deux méthodes, à savoir les méthodes GetContact et GetContacts. Alors que la première renvoie un enregistrement de contact en fonction de l'ID qui lui est passé en paramètre, la seconde renvoie tous les contacts.

La liste de codes suivante illustre à la fois l’interface IContactRepository et la classe ContactRepository.

public interface IContactRepository
{
    public Contact GetContact(int id);
    public List GetContacts();
}
public class ContactRepository: IContactRepository
{
    private readonly List contacts = new List();
    public ContactRepository()
    {
        contacts = new List()
        {
            new Contact()
            { Id =1, FirstName = "Keaton", LastName = "Underwood",
                Address = "12/3 ABC Road, Chicago, USA",
            Phone = "1234567890"},
            new Contact(){ Id = 2, FirstName = "John", LastName = "Smith",
                Address = "12/3 ABC Road, New York, USA",
            Phone = "0987654321"}
        };
    }
    public Contact GetContact(int id)
    {
        return contacts.SingleOrDefault(c => c.Id == id);
    }
    public List GetContacts()
    {
        return contacts;
    }
}

Vous pouvez enregistrer une instance de type IContactRepository avec la collection de services dans Program.cs à l'aide du morceau de code suivant.

builder.Services.AddScoped();

Cela vous permettra d'utiliser l'injection de dépendances pour créer une instance de type IContactRepository dans l'application.

Créer le contrôleur API

Créons maintenant la classe contrôleur pour notre API Contacts. Pour ce faire, créez un nouveau contrôleur d'API nommé ContactsController et remplacez le code généré par le code suivant.

using Microsoft.AspNetCore.Mvc;
namespace Refit_Demo.Controllers
{
    (Route("api/(controller)"))
    (ApiController)
    public class ContactsController : ControllerBase
    {
        private readonly IContactRepository _contactRepository;
        public ContactsController(IContactRepository contactRepository)
        {
            _contactRepository = contactRepository;
        }
        (HttpGet)
        public async Task> Get()
        {
            return await _contactRepository.GetContacts();
        }
        (HttpGet("{id}"))
        public async Task Get(int id)
        {
            return await _contactRepository.GetContact(id);
        }
    }
}

Notez comment nous avons utilisé l’injection de constructeur pour créer une instance de type IContactRepository dans la liste de codes précédente.

Dans les sections suivantes, nous allons créer un projet d’application console et créer le client Refit qui consommera notre API de contacts.

Créer un projet d'application console .NET Core dans Visual Studio

Suivez les étapes décrites ci-dessous pour créer un nouveau projet d’application de console .NET Core dans Visual Studio.

1. Lancez l’IDE ​​Visual Studio.
2. Cliquez sur « Créer un nouveau projet ».
3. Dans la fenêtre « Créer un nouveau projet », sélectionnez « Application console (.NET Core) » dans la liste des modèles affichés.
4. Cliquez sur Suivant.
5. Dans la fenêtre « Configurer votre nouveau projet », spécifiez le nom et l’emplacement du nouveau projet.
6. Cliquez sur Suivant.
7. Dans la fenêtre « Informations supplémentaires » affichée ci-dessous, choisissez « .NET 8.0 (Long Term Support) » comme version du framework que vous souhaitez utiliser.
8. Cliquez sur Créer.

Nous utiliserons ce projet d’application console .NET Core pour créer notre client API Refit.

Installer le package NuGet Refit

Pour installer Refit dans votre projet, sélectionnez le projet dans la fenêtre de l'Explorateur de solutions, puis cliquez avec le bouton droit et sélectionnez « Gérer les packages NuGet ».

Dans la fenêtre du gestionnaire de packages NuGet, recherchez le package Refit et installez-le. Vous pouvez également installer le ou les packages via la console du gestionnaire de packages NuGet en saisissant les commandes ci-dessous.

PM> Réaménagement du package d'installation

Créer le client API Refit

Remplacez maintenant le code généré dans le fichier Program.cs par la liste de codes suivante.

using Refit;
string baseAddress = "http://localhost:59904/";
var contactsAPI = RestService.For(baseAddress);
var contacts = await contactsAPI.GetContacts();
foreach (var contact in contacts)
{
    Console.WriteLine($"{contact.Id} | {contact.FirstName} |
    {contact.LastName}");
}
Console.ReadLine();
(Headers("Accept: application/json", "Content-type: application/json"))
public interface IContactService
{
    (Get("/api/contacts"))
    public Task GetContact(int id);
    (Get("/api/contacts"))
    public Task> GetContacts();
}
public class Contact
{
    public int Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Address { get; set; }
    public string Phone { get; set; }
}

Exécuter l'application

Comme il y a deux applications dans cet exemple, vous devez les exécuter une par une. Tout d'abord, exécutez l'application API, puis l'application de console cliente API. Une fois les deux applications lancées, vous verrez les données récupérées à partir de l'application API Contacts affichées sur la console, comme illustré dans la Figure 1.

IDG

Refit est un excellent choix pour implémenter des clients API REST HTTP. Refit simplifie grandement le code standard requis pour se connecter et utiliser les API REST dans vos applications ASP.NET Core. Un point important à noter est que lorsque vous utilisez Refit, toutes les requêtes doivent être asynchrones. Refit ne prend pas en charge les appels réseau synchrones.