Prenez en main ASP.NET Core

Inès a relu votre refactoring et l’a intégré à la branche principale. Elle n’a laissé qu’un commentaire, sur le constructeur du contrôleur : « Avant qu’on ajoute les stages, je ne veux plus voir un seulnewici. » Le même jour, Samuel transfère un message de Karim Benali : depuis que l’équipe a importé l’historique des congés des cinq dernières années, approuver une demande prend plusieurs secondes.

Ces deux remarques semblent sans rapport. Elles ont pourtant la même origine : Hamac utilise ASP.NET Core et Entity Framework Core sans profiter de ce qu’ils proposent. Le framework sait créer et assembler les objets de l’application, mais Hamac les crée à la main. Entity Framework Core sait filtrer les données dans la base, mais Hamac les filtre en mémoire.

Découvrez le rôle de Program.cs

Jusqu’ici, vous avez travaillé dans le contrôleur et dans le service. Mais avant qu’une requête n’atteigneLeaveController, quelque chose a démarré l’application, ouvert le port 5110 et décidé quel code appeler. Tout cela se passe danssrc/Hamac.Api/Program.cs. Voici sa version actuelle :

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllers();

var app = builder.Build();

using (var db = new HamacDbContext())
{
    DemoData.Reset(db);
}

app.MapControllers();

app.Run();

Ce fichier se lit en deux temps, séparés par l’appel àbuilder.Build().

AvantBuild(), vous configurez les services de l’application : tout ce dont elle aura besoin pour fonctionner. Pour l’instant, une seule ligne :AddControllers(), qui indique au framework que l’application utilise des contrôleurs. Retenez l’endroit, c’est là que vous allez travailler.

AprèsBuild(), vous configurez le pipeline : ce qui se passe à chaque requête reçue.MapControllers()associe les routes déclarées dans les contrôleurs, commeapi/leave/approve, aux méthodes qui les traitent.Run()démarre le serveur et attend les requêtes.

Entre les deux, le starter réinitialise la base de démonstration. C’est ce bloc qui vous permet de retrouver la demande n° 7 en attente à chaque relance de l’API. Remarquez qu’il crée lui aussi sonHamacDbContextavecnew.

Lorsqu’une requête arrive, elle traverse une série de composants appelés middlewares, dans l’ordre où ils ont été ajoutés au pipeline. Chacun peut agir sur la requête, puis la passer au suivant : l’un gère les erreurs, un autre l’authentification, un autre encore le routage. Le dernier maillon, ici, est le contrôleur.

Hamac n’ajoute pour l’instant aucun middleware particulier. Vous en ajouterez un au chapitre 6, pour autoriser le front-end Blazor à appeler l’API. Ce qui compte dès maintenant, c’est ce qui se passe au bout du pipeline : le framework crée lui-même une instance deLeaveControllerà chaque requête. Vous n’écrivez nulle partnew LeaveController().

Confiez la création des objets au conteneur .NET

ASP.NET Core intègre un conteneur d’injection de dépendances. C’est un registre dans lequel vous déclarez, au démarrage, comment obtenir chaque service : « quand une classe a besoin d’unILeaveNotifier, fournis-lui unNotificationService». Lorsque le framework doit créer un contrôleur, il examine son constructeur, cherche dans le registre chacun des paramètres demandés, les crée à leur tour si besoin, et assemble le tout.

Vous connaissez déjà l’injection par constructeur. Le conteneur ne change rien à vos classes :LeaveServicereçoit toujours ses collaborateurs par son constructeur, exactement comme au chapitre précédent. Ce qui change, c’est qui écrit lesnew.

Objet

Créé par, dans la version intermédiaire

Créé par, à la fin de ce chapitre

HamacDbContext

Le constructeur du contrôleur etProgram.cs

Le conteneur

Les politiques et le résolveur

Le constructeur du contrôleur

Le conteneur

NotificationService

Le constructeur du contrôleur

Le conteneur

LeaveService

Le constructeur du contrôleur

Le conteneur

LeaveController

Le framework

Le framework, qui lui fournit son service

L’assemblage de l’application se trouve désormais en un seul endroit,Program.cs. On appelle cet endroit le point d’assemblage (composition root en anglais). C’est le seul fichier qui connaît toutes les classes concrètes, et c’est le seul que vous modifierez pour remplacer une implémentation par une autre.

Chaque service s’enregistre par une ligne, avant l’appel àBuild(). Pour le service des congés et le notificateur, cela donne :

builder.Services.AddScoped<ILeaveNotifier, NotificationService>();
builder.Services.AddScoped<LeaveService>();

La première ligne associe une abstraction à son implémentation : quand une classe demande unILeaveNotifier, le conteneur crée unNotificationService. La seconde enregistre une classe concrète, que les autres demanderont directement par son nom.

Faut-il créer une interfaceILeaveServicepour que le contrôleur ne dépende pas de la classe concrète ? 

Ce n’est pas nécessaire ici. Il n’existe qu’une implémentation du service, et le contrôleur est testé à travers l’API, avec le vrai service. Une interface sans second usage ajoute un fichier sans réduire aucun risque. Vous la créerez le jour où un besoin concret apparaîtra, par exemple pour remplacer le service dans un test du contrôleur.

Choisissez la bonne durée de vie

Le motScopedn’est pas anodin. En enregistrant un service, vous indiquez aussi sa durée de vie, c’est-à-dire combien de temps le conteneur réutilise la même instance avant d’en créer une nouvelle :

Durée de vie

Une instance…

Adaptée à…

Dans Hamac

Transient

à chaque fois qu’on la demande

des objets légers et sans état

Aucun service pour l’instant

Scoped

par requête HTTP

ce qui dépend d’un contexte de requête, en particulier l’accès aux données

HamacDbContext,LeaveService,NotificationService

Singleton

pour toute la durée de vie de l’application

des objets sans état, partagés sans risque entre les requêtes

Les politiques de calcul et le résolveur

Les politiques de calcul se prêtent bien au singleton : elles ne contiennent que des constantes, et deux requêtes simultanées peuvent les utiliser sans se gêner. LeHamacDbContext, lui, doit absolument être scoped. Il garde en mémoire les entités qu’il a chargées, et il n’est pas conçu pour être utilisé par plusieurs requêtes en même temps. Partagé entre toutes les requêtes, il accumulerait les entités de toute la journée et produirait des erreurs dès que deux managers approuveraient une demande au même moment.

Injectez par constructeur

Une fois les services enregistrés, le contrôleur n’a plus qu’à déclarer ce dont il a besoin :

public LeaveController(LeaveService leaveService) =>
    _leaveService = leaveService;

À chaque requête, le framework crée le contrôleur. Pour satisfaire son constructeur, le conteneur crée unLeaveService. Pour satisfaire celui du service, il fournit leHamacDbContextde la requête, le résolveur et unNotificationService. Vous n’avez écrit aucune de ces étapes : le conteneur a lu les constructeurs et reconstitué l’arbre des dépendances.

Laissez le conteneur fournir toutes les politiques

Reste le résolveur. Au chapitre précédent, il recevait un dictionnaire construit à la main dans le contrôleur. Vous pourriez déplacer ce dictionnaire dansProgram.cs, mais le conteneur propose mieux : si vous enregistrez plusieurs implémentations de la même interface, une classe peut toutes les recevoir en demandant unIEnumerablede cette interface.

Pour en profiter, chaque politique doit indiquer elle-même le type de contrat qu’elle traite. Ajoutez une propriété au contrat :

public interface ILeaveEntitlementPolicy
{
    string ContractType { get; }
    double ComputeEntitlement(Employee employee, DateTime today);
}

Le résolveur reçoit alors toutes les politiques enregistrées et construit lui-même son dictionnaire :

public LeavePolicyResolver(IEnumerable<ILeaveEntitlementPolicy> policies) =>
    _policies = policies.ToDictionary(policy => policy.ContractType);

Le bénéfice se mesure avec les stages. Avec le dictionnaire écrit à la main, ajouter une politique demandait de créer la classe, puis de penser à la déclarer au bon endroit dans une collection. Désormais, il suffit de créer la classe et d’ajouter une ligne d’enregistrement dansProgram.cs. Le résolveur, le service et le contrôleur ne changent pas : le principe ouvert/fermé est mieux respecté qu’au chapitre précédent.

ToDictionaryapporte aussi une protection. Si deux politiques déclarent le même type de contrat, par exemple après un copier-coller oublié, il lève une exception à la création du résolveur. L’erreur de configuration apparaît dès le premier appel, au lieu de produire un calcul faux sans rien signaler.

Accédez aux données avec Entity Framework Core

Vous utilisezHamacDbContextdepuis le début du cours sans vous être arrêté sur son fonctionnement. C’est le moment, car le problème signalé par Karim en dépend.

UnDbContextreprésente une session de travail avec la base de données. Il expose une propriétéDbSetpar type d’entité :EmployeesetLeaveRequestsdans Hamac. UnDbSetne contient pas les données : c’est un point de départ pour écrire des requêtes, que leDbContexttraduit en SQL au moment de les exécuter.

LeDbContextjoue un second rôle, moins visible : il suit les entités qu’il a chargées. LorsqueApprovemodifierequest.Statuspuis appelleSaveChanges(), vous n’écrivez aucune requêteUPDATE. LeDbContextcompare l’état actuel des entités à celui qu’elles avaient au chargement, et génère lui-même les modifications à envoyer. C’est aussi pour cette raison qu’il doit vivre le temps d’une requête, pas davantage.

Configurez le DbContext par injection

Dans le starter,HamacDbContextchoisit lui-même sa base de données :

public class HamacDbContext : DbContext
{
    public DbSet<Employee> Employees { get; set; }
    public DbSet<LeaveRequest> LeaveRequests { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder options) =>
        options.UseSqlite("Data Source=hamac.db");
}

La chaîne de connexion est écrite dans le code. Pour utiliser une autre base, en test ou en production, il faudrait modifier la classe et la recompiler. Pour que le conteneur puisse fournir leDbContext, celui-ci doit plutôt recevoir sa configuration par son constructeur, sous la forme d’un objetDbContextOptions. La chaîne de connexion, elle, rejoint le fichier de configurationappsettings.json, etProgram.csfait le lien entre les deux avecAddDbContext. Vous écrirez ces trois éléments dans l’activité.

AddDbContextenregistre leDbContextavec une durée de vie scoped : vous n’avez pas à la préciser.

Observez les requêtes SQL

Pour comprendre la lenteur signalée par Karim, il faut voir ce qu’Entity Framework Core envoie réellement à la base. Activez le journal des commandes SQL danssrc/Hamac.Api/appsettings.Development.json:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning",
      "Microsoft.EntityFrameworkCore.Database.Command": "Information"
    }
  }
}

Relancez l’API, puis approuvez une demande aveccurl. Dans le terminal de l’API, vous voyez apparaître la requête exécutée par la ligne_db.LeaveRequests.ToList()(simplifiée ici) :

SELECT "l"."Id", "l"."EmployeeId", "l"."EndDate", "l"."StartDate", "l"."Status", "l"."WorkingDays"
FROM "LeaveRequests" AS "l"

Aucune clauseWHERE: la base renvoie toutes les demandes de congés.ToList()a déclenché l’exécution de la requête, et leFirstOrDefaultqui suit cherche ensuite la bonne demande en C#, parmi toutes les lignes chargées. Avec les quelques demandes de la base de démonstration, c’est imperceptible. Avec cinq années d’historique, chaque approbation transfère des dizaines de milliers de lignes pour n’en garder qu’une.

Corrigez le filtrage en mémoire

La règle à retenir découle du petit rappel de début de chapitre : tout ce qui est écrit avant l’exécution de la requête est traduit en SQL ; tout ce qui est écrit après s’exécute en mémoire. Pour que la base fasse le tri, le filtre doit donc précéder l’exécution.

Pour rechercher une entité par sa clé primaire, Entity Framework Core propose une méthode dédiée,Find, queApproveutilise déjà pour le salarié :

var request = _db.LeaveRequests.Find(requestId);

La requête générée contient désormais le filtre :

SELECT "l"."Id", "l"."EmployeeId", "l"."EndDate", "l"."StartDate", "l"."Status", "l"."WorkingDays"
FROM "LeaveRequests" AS "l"
WHERE "l"."Id" = @p
LIMIT 1

Finda un avantage supplémentaire : si l’entité a déjà été chargée par le mêmeDbContext, elle la renvoie sans interroger la base. Pour une recherche sur un autre critère que la clé, vous écririez_db.LeaveRequests.FirstOrDefault(r => r.EmployeeId == employeeId), sansToList()devant : le filtre serait alors traduit en SQL.

Diagnostiquez une erreur d’injection

Le conteneur vous libère de l’assemblage manuel, mais il déplace une partie des erreurs. Une dépendance oubliée ne provoque plus d’erreur de compilation : elle se révèle à l’exécution, par un message parfois long. Ces messages se lisent toujours de la même façon : repérez la classe que le conteneur essayait de créer, puis le type qu’il n’a pas su fournir.

Voici les trois erreurs que vous avez le plus de chances de rencontrer :

Ce que vous avez oublié

Quand l’erreur apparaît

Le message (extrait)

EnregistrerLeaveService

À la première requête vers le contrôleur, qui renvoie une erreur 500

Unable to resolve service for type 'LeaveService' while attempting to activate 'LeaveController'.

EnregistrerILeaveNotifier, dont dépendLeaveService

Au démarrage de l’application, en développement

Error while validating the service descriptor 'ServiceType: LeaveService' […] Unable to resolve service for type 'ILeaveNotifier' while attempting to activate 'LeaveService'.

Respecter les durées de vie (LeaveServiceen singleton)

Au démarrage, en développement

Cannot consume scoped service 'HamacDbContext' from singleton 'LeaveService'.

Pourquoi ces différences de moment ? En environnement de développement, celui qu’utilisedotnet rungrâce au fichierlaunchSettings.json, ASP.NET Core vérifie au démarrage que chaque service enregistré peut être construit. Mais les contrôleurs ne sont pas enregistrés dans le conteneur : le framework les crée à la demande. Une dépendance manquante dans un contrôleur ne se révèle donc qu’à la première requête qui l’atteint. C’est une bonne raison de lancer les tests d’API après chaque modification deProgram.cs.

À vous de jouer

Inès souhaite livrer la correction de la lenteur avant la fin de la semaine, et Samuel a prévenu Karim. Elle vous demande de traiter les deux sujets dans la même livraison, mais en deux commits distincts : d’abord l’injection, puis le filtrage. Le comportement de l’API ne doit pas changer.

  1. Activez le journal des commandes SQL, approuvez une demande et repérez la requête qui charge toute la table.

  2. Ajoutez àHamacDbContextun constructeur qui reçoit unDbContextOptions<HamacDbContext>, supprimezOnConfiguringet déplacez la chaîne de connexion dansappsettings.json, sous le nomHamac.

  3. Ajoutez la propriétéContractTypeau contrat des politiques, implémentez-la dans les trois politiques et faites recevoir au résolveur unIEnumerable&lt;ILeaveEntitlementPolicy&gt;.

  4. DansProgram.cs, enregistrez leDbContext, les politiques, le résolveur, le notificateur et le service, avec des durées de vie adaptées. Faites aussi passer la réinitialisation de la base par le conteneur.

  5. Remplacez le constructeur deLeaveControllerpar une injection du service. Lancez les tests, puis enregistrez votre premier commit.

  6. Corrigez le filtrage en mémoire dansApprove, vérifiez la nouvelle requête SQL dans le journal, puis enregistrez votre second commit.

  7. Ajoutez un test qui vérifie que le conteneur sait construireLeaveService.

Point de contrôle : le mot-clénewn’apparaît plus dans le contrôleur ni dansProgram.cspour créer un service. Tous les tests passent, y compris le nouveau. Le journal SQL montre une clauseWHERElors de l’approbation.

En résumé

  • Program.csse lit en deux temps : avantBuild(), on configure les services ; après, on configure le pipeline des requêtes.

  • Le framework crée lui-même les contrôleurs. Le conteneur d’injection leur fournit leurs dépendances en lisant les constructeurs, etProgram.csdevient le point d’assemblage : le seul endroit qui connaît les classes concrètes.

  • Chaque service a une durée de vie : transient, scoped ou singleton. LeDbContextest scoped, et un service ne doit jamais vivre plus longtemps que ses dépendances.

  • Avec Entity Framework Core, tout ce qui précède l’exécution de la requête est traduit en SQL. UnToList()placé trop tôt fait filtrer en mémoire ce que la base aurait dû filtrer.

  • Une erreur d’injection se lit toujours de la même façon : quelle classe le conteneur essayait-il de créer, et quel type n’a-t-il pas su fournir ?

Hamac s’appuie désormais sur son framework, et l’approbation ne charge plus toute la table des demandes. Il reste un défaut que vous avez repéré dès le chapitre 2 : une simple requête GET suffit à approuver une demande, et l’API répond 200 même en cas d’erreur. Dans le prochain chapitre, vous allez reprendre le contrat de l’API : routes, verbes, statuts, DTO et validation.

Ever considered an OpenClassrooms diploma?
  • Up to 100% of your training program funded
  • Flexible start date
  • Career-focused projects
  • Individual mentoring
Find the training program and funding option that suits you best