Construire un Clone Postman: Conception de bibliothèque de classes pour des appels d'API

Introduction et Installation

Tim commence par expliquer l'objectif de cette leçon : créer la logique métier et la couche d'accès aux données pour faire fonctionner les appels API dans l'application. Il souligne qu'il s'agit d'un MVP — une version fonctionnelle qui peut être étendue ultérieurement.

Avant de plonger dans le code, Tim note que le cours est conçu pour être adapté à un portfolio, bien qu'il mette en garde contre la copie directe du projet. Il encourage plutôt les développeurs à l'utiliser comme source d'inspiration pour créer des projets uniques qui démontrent des compétences en C#, interaction avec les API et conception d'interface utilisateur.

Création de la classe d'accès à l'API

Tim nous guide à travers l'ouverture de la bibliothèque de classes et le démarrage d'une base saine. Il supprime la classe par défaut Class1 et crée une nouvelle classe nommée APIAccess. Celle-ci gérera toutes les interactions avec l'API.

Il explique son approche de la conception des méthodes : commencer avec des méthodes public void, ajouter des paramètres comme string url, puis les raffiner progressivement en tâches asynchrones capables de gérer des requêtes API réelles.

public class APIAccess
{
    private readonly HttpClient client = new();

    public async Task<string> CallApiAsync(string url)
    {
        var response = await client.GetAsync(url);
        if (response.IsSuccessStatusCode)
        {
            return await response.Content.ReadAsStringAsync();
        }
        return $"erreur : {response.StatusCode}";
    }
}

Tim insiste sur la création d'une instance unique de client HTTP pour éviter de la réinitialiser à chaque appel, ce qui améliore les performances.

Gestion des Réponses API

Une fois que le client HTTP est en place, Tim montre comment récupérer la réponse de l'appel API. Il souligne l'importance de retourner une Task au lieu de async void, sauf dans les gestionnaires d'événements.

Pour le démontrer, Tim utilise une API d'exemple de JSON Placeholder, qui fournit de fausses données comme des posts, des commentaires et des todos. Il colle l'URL de l'API dans le formulaire de l'interface utilisateur HTML et utilise le champ results.Text pour afficher la réponse HTML ou JSON.

results.Text = await api.CallApiAsync(apiText.Text);

Tim note que la sortie JSON brute est lisible par ordinateur mais pas conviviale, ce qui mène à l'étape suivante : le formatage du JSON.

Formatage de la sortie JSON

Tim montre comment rendre la réponse JSON plus lisible à l'aide de JsonSerializer :

var jsonElement = JsonSerializer.Deserialize<JsonElement>(responseJson);
var prettyJson = JsonSerializer.Serialize(jsonElement, new JsonSerializerOptions { WriteIndented = true });

Cela permet aux développeurs d'afficher un JSON amélioré dans l'interface utilisateur, ce qui est plus facile à lire dans les éditeurs de texte JSON ou lors des tests de points d'accès. Tim ajoute également une option pour basculer entre la sortie brute et la sortie formatée, offrant ainsi une flexibilité selon que les données seront affichées dans l'interface utilisateur ou traitées de manière programmatique.

Planification pour des améliorations futures

Même si le MVP ne prend en charge que les requêtes GET, Tim montre comment planifier d'autres actions HTTP telles que POST, PATCH, PUT et DELETE. Il crée une énumération appelée HTTPAction avec une valeur par défaut de GET, préparant le code à évoluer sans réécrire les méthodes existantes.

public enum HTTPAction
{
    GET
}

Cette conception prévoyante est une excellente pratique pour les développeurs qui souhaitent construire leur propre clone de Postman maintenable et extensible.

Validation de l'URL

Tim introduit une méthode de validation d'URL pour s'assurer que les utilisateurs ne fournissent que des points d'accès HTTPS valides :

public bool IsValidURL(string url)
{
    if (string.IsNullOrWhiteSpace(url)) return false;
    return Uri.TryCreate(url, UriKind.Absolute, out Uri uriResult) && uriResult.Scheme == Uri.UriSchemeHttps;
}

Il explique qu'il est important de ne jamais faire confiance aux entrées utilisateur et de les valider plusieurs fois si nécessaire. Cela garantit que l'application ne se brise pas en raison d'URLs invalides et empêche les messages d'erreur de perturber le flux de travail.

Intégration de l'accès aux API avec l'interface utilisateur

Une fois la validation en place, Tim montre comment intégrer l'accès à l'API avec l'interface du tableau de bord :

1. Instancier la classe APIAccess.

2. Valider l'URL.

3. Afficher la réponse JSON dans l'éditeur de texte des résultats.

4. Afficher des messages d'erreur significatifs pour les requêtes invalides ou échouées.

if (!api.IsValidURL(apiText.Text))
{
    systemStatus.Text = "URL invalide";
    results.Text = string.Empty;
    return;
}
results.Text = await api.CallApiAsync(apiText.Text);

Tim souligne l'importance d'un design de l'interface utilisateur clair, commençant chaque requête avec une zone de résultats vide et mettant à jour le statut du système en fonction de la réussite ou de l'échec.

Utilisation des Interfaces pour l'injection de dépendances et les tests unitaires

Tim introduit IAPIAccess, une interface pour APIAccess. C'est une bonne pratique pour les tests unitaires et pour préparer le code à l'injection de dépendance :

public interface IAPIAccess
{
    Task<string> CallApiAsync(string url);
    bool IsValidURL(string url);
}

En codant contre une interface plutôt que la classe concrète, les développeurs peuvent échanger les implémentations pour les tests ou mettre à niveau la logique de l'API sans changer l'interface utilisateur ou les autres codes dépendants. Tim souligne que bien que ce soit légèrement exagéré pour le MVP, c'est précieux pour les futurs ajouts d'applications.

Test et exécution de l'application

Avec toutes les pièces en place, Tim exécute l'application sur Windows, colle l'URL JSON Placeholder et affiche avec succès la réponse JSON formatée. Il montre comment les URLs invalides sont correctement rejetées, assurant que l'application est robuste même avec des erreurs d'entrées utilisateur.

Cela forme un clone de Postman fonctionnel capable de faire des requêtes GET, de valider des entrées et d'afficher des réponses dans un format convivial.

Étapes suivantes : Intégrer dans un portfolio et sur GitHub

Tim conclut la leçon en soulignant l'importance de transformer ce projet en un élément prêt à être intégré dans un portfolio. Il suggère :

• Créer un dépôt GitHub pour le projet.

• Ajouter un README clair qui explique l'application.

• Inclure un exécutable téléchargeable pour que d'autres puissent tester.

• Mettre en valeur l'interface utilisateur et les fonctionnalités avec des captures d'écran ou des GIFs.

• Documenter le processus, l'installation et la structure du code.

Il met en garde contre simplement copier son code et le télécharger à votre propre nom. Les développeurs devraient plutôt utiliser ces leçons pour créer leur propre clone de Postman ou une application similaire qui reflète leur style et leur ensemble de compétences.

En suivant cette approche, les développeurs montrent non seulement leur compétence en codage, mais aussi leur capacité à explorer, mettre à jour et maintenir un projet logiciel, ce qui est inestimable pour les employeurs potentiels.

Conclusion

La vidéo de Tim Corey donne un guide complet pour construire un clone de Postman à partir de zéro. De la configuration d'une bibliothèque de classes à la gestion des appels API, en formattant les réponses JSON, en validant les entrées, et en préparant le projet pour des améliorations futures avec des interfaces et l'injection de dépendance, cette leçon couvre un processus de développement d'application complet.

En suivant cette approche, les développeurs peuvent créer un clone de Postman MVP en utilisant uniquement C#, intégrer des éléments d'interface utilisateur pour afficher des réponses HTML ou JSON, et préparer un projet GitHub prêt à être présenté dans un portfolio. Cette méthodologie étape par étape n'enseigne pas seulement le code, mais met également l'accent sur la planification, le processus et la réflexion sur la conception, qui sont des compétences cruciales pour les développeurs de logiciels professionnels.