Carbon IT · Préparation RT client

RT modernisation legacy .NET

Questions posées lors d'un RT .NET sur une mission de modernisation d'un legacy, et un exercice de revue de code pour s'entraîner. Formule ta réponse à voix haute, puis déplie pour comparer.

0 maîtrisée · 0 à revoir

Contexte de la mission

Une équipe de modernisation remplace progressivement un monolithe .NET Framework par des services .NET 10. Chaque élément de cette stack peut donner lieu à une question.

SujetLegacyCible
Runtime.NET Framework 4.7, Azure DevOps.NET 10, GitLab
DonnéesSQL Server monolithique, plusieurs centaines de tablesDonnées découpées par domaine (catalogue en premier)
Migration—Strangler Fig avec dual run ancien / nouveau
ArchitectureMonolitheClean Architecture, pattern Mediator, Kafka
Performance—Cache (FusionCache, fail-safe)
Tests—Unitaires, intégration, snapshot
Infra et runLogs ElasticsearchGCP, cluster GKE géré par les ops

Questions de parcours à préparer sans réponse type :

  • Présente une modernisation de legacy que tu as menée : point de départ, découpage, ce que tu referais autrement.
  • Comment as-tu remplacé des procédures stockées sans casser le comportement existant ?
  • Sur 10, où te situes-tu en EF Core, et qu'est-ce qui te manque pour gagner 2 points ?
  • As-tu déjà travaillé en événementiel (Kafka, RabbitMQ) en production ? Sinon, que retiens-tu de tes essais ?

Modernisation du legacy

Le cœur de la mission : migrer sans interrompre un service utilisé tous les jours.

Comment faire évoluer une API sans casser le contrat de ses clients ?

On fige le comportement actuel dans des tests avant de toucher au code, puis on vérifie à chaque changement que la sortie est identique. C'est le principe du Golden Master, aussi appelé test de caractérisation.

  • Golden Master : on enregistre les réponses réelles de l'API (ou du legacy) sur un jeu d'entrées représentatif. Ce fichier de référence devient la vérité. Après refacto, toute différence fait échouer le test.
  • Snapshot testing : la même idée outillée. En .NET, la librairie Verify sérialise le résultat, le compare au fichier .verified et montre le diff.
  • Dual run : en production, on envoie la même requête à l'ancien et au nouveau système, on renvoie la réponse de l'ancien et on journalise les écarts. C'est un Golden Master à l'échelle du trafic réel.
  • Tests de contrat (Pact) : chaque consommateur déclare ce qu'il attend, le fournisseur vérifie qu'il le respecte.
  • Règles de compatibilité : ajouter un champ optionnel est sans risque ; renommer, supprimer ou rendre obligatoire un champ est cassant et passe par une nouvelle version (/v2, header) avec une période de dépréciation.
// Test de caractérisation avec Verify : le premier run crée le fichier de référence
[Fact]
public async Task Get_product_keeps_legacy_contract()
{
    var response = await _client.GetStringAsync("/products/42");
    await VerifyJson(response);
}
PiègeDécrire l'idée sans connaître le mot fait perdre des points. Cite « Golden Master » ou « test de caractérisation », puis montre que tu sais gérer les champs instables (dates, identifiants générés) : Verify les remplace par des valeurs fixes (scrubbers).
Comment mettre en place un Strangler Fig avec un dual run ancien / nouveau ?

On place une façade devant le legacy, puis on redirige les fonctionnalités une par une vers le nouveau système, jusqu'à ce que l'ancien n'ait plus rien à servir.

  1. Façade : un reverse proxy (YARP, API gateway, ingress) reçoit tout le trafic et le route vers l'ancien par défaut.
  2. Découpage : on choisit un périmètre cohérent et peu couplé, ici le catalogue.
  3. Dual run : le nouveau service reçoit une copie du trafic (shadow). On compare les réponses, on corrige les écarts, sans impact client.
  4. Bascule progressive : feature flag ou pourcentage de trafic, avec retour arrière immédiat possible.
  5. Données : tant que les deux systèmes vivent, il faut synchroniser. Événements Kafka publiés à chaque écriture, ou CDC (Change Data Capture) sur la base legacy.
  6. Décommission : on supprime le code legacy du périmètre une fois la bascule stabilisée.
ConseilParle des risques : double écriture incohérente, latence ajoutée par la façade, coût de faire tourner deux systèmes. Une couche anti-corruption (ACL) traduit le modèle du legacy pour qu'il ne contamine pas le nouveau domaine.
Une base monolithique de plusieurs centaines de tables et des procédures stockées métier : comment les sortir vers le code .NET ?

Progressivement et sous filet de sécurité : on caractérise d'abord le comportement de la procédure, puis on réécrit la règle dans le domaine, et on compare les résultats avant de basculer.

  • Cartographier : quelles procédures, appelées par qui, sur quelles tables. Les dépendances croisées dictent l'ordre.
  • Écrire des tests de caractérisation sur la procédure (entrées, sorties, effets sur les tables).
  • Extraire la règle métier dans le domaine ; garder en SQL ce qui est purement ensembliste et performant (gros agrégats, batchs).
  • Définir un propriétaire par table : un service écrit, les autres lisent via API ou événements. Sans ça, le découpage reste un monolithe distribué.
Piège« Tout remplacer par EF Core » n'est pas une stratégie. Montre que tu sais quand garder du SQL (Dapper, FromSql) et quand la règle doit vivre dans le code pour être testée.

Architecture et DDD

Clean Architecture, Mediator et modélisation du domaine.

Qu'est-ce qu'un Value Object ? Donne un exemple.

Un Value Object est un objet du domaine défini uniquement par ses valeurs, sans identité propre. Deux Value Objects avec les mêmes valeurs sont égaux, et ils sont immuables.

EntitéValue Object
IdentitéUn identifiant (Movie.Id)Aucune, seulement ses valeurs
ÉgalitéMême IdMêmes valeurs
Cycle de vieÉvolue dans le tempsImmuable : on le remplace
ExemplesCommande, Client, ProduitPrix + devise, adresse, code postal, EAN
public sealed record PostalCode
{
    public string Value { get; }

    public PostalCode(string value)
    {
        if (!Regex.IsMatch(value, @"^\d{5}$"))
            throw new ArgumentException("Code postal invalide", nameof(value));
        Value = value;
    }
}
  • La validation est faite une fois, à la construction : un PostalCode existant est forcément valide. Fini les string vérifiées partout (« primitive obsession »).
  • Un record C# donne l'égalité par valeur gratuitement.
  • Avec EF Core : OwnsOne / OwnsMany, ou ComplexProperty depuis EF Core 8.
Lien avec l'exerciceL'exemplaire de l'exercice d'entraînement (support, état, code-barres) est un Value Object type. Le dire pendant la revue de code montre que tu fais le lien.
Comment s'assurer que toute l'équipe respecte la Clean Architecture ?

La revue de code ne suffit pas : on écrit les règles d'architecture sous forme de tests, exécutés dans la CI. Une dépendance interdite fait échouer le build.

// NetArchTest (ArchUnitNET est une alternative)
[Fact]
public void Domain_does_not_depend_on_infrastructure()
{
    var result = Types.InAssembly(typeof(Product).Assembly)
        .That().ResideInNamespace("Catalog.Domain")
        .ShouldNot().HaveDependencyOn("Catalog.Infrastructure")
        .GetResult();

    Assert.True(result.IsSuccessful);
}
  • Références de projets : le projet Domain ne référence rien. Le compilateur bloque déjà une partie des erreurs.
  • Tests d'architecture : dépendances entre couches, conventions de nommage (un handler finit par Handler), classes sealed.
  • Analyseurs Roslyn et .editorconfig : règles de style en erreur de build.
  • Revue de code : reste utile pour le reste (lisibilité, choix de conception).
PiègeRépondre seulement « en revue de code » montre qu'on n'a jamais automatisé. Cite au moins NetArchTest ou ArchUnitNET.
À quoi sert le pattern Mediator dans une Clean Architecture ?

Le contrôleur envoie une commande ou une requête à un médiateur, qui la transmet au handler correspondant. Le contrôleur ne connaît plus les services métier, et chaque cas d'usage vit dans sa propre classe.

  • Un cas d'usage = une commande (CreateProduct) + un handler : facile à trouver et à tester.
  • Pipeline behaviors : validation, logs, transaction, cache appliqués à tous les handlers sans les modifier.
  • Va bien avec CQRS : commandes qui écrivent, requêtes qui lisent, éventuellement sur des modèles différents.
  • Librairies : MediatR (sous licence commerciale depuis 2025), Mediator (générateur de sources), Wolverine, ou une implémentation maison de quelques dizaines de lignes.
PiègeLe Mediator ajoute une indirection : on ne navigue plus directement du contrôleur au code. Sur un petit service, c'est souvent de la cérémonie. Un avis nuancé vaut mieux qu'un enthousiasme sans réserve.

Cache, résilience et tests

Un catalogue est lu beaucoup plus qu'il n'est écrit : le cache est central.

Connais-tu FusionCache ? Qu'est-ce que le mécanisme de fail-safe ?

FusionCache est une librairie de cache .NET hybride : un cache mémoire (L1), un cache distribué optionnel (L2, Redis) et des mécanismes de résilience. Le fail-safe permet de resservir une valeur expirée quand la source de données est en panne.

  • Fail-safe : une entrée expirée est gardée en réserve. Si l'appel à la base ou à l'API échoue, on renvoie l'ancienne valeur au lieu d'une erreur. Mieux vaut une donnée d'il y a 10 minutes qu'une page en erreur.
  • Protection contre le cache stampede : quand une clé expire, une seule requête recharge la donnée, les autres attendent son résultat.
  • Factory timeouts : si la source répond lentement, on renvoie la valeur périmée tout de suite et on termine le chargement en arrière-plan.
  • Backplane : avec plusieurs pods, une invalidation est propagée aux caches mémoire des autres instances.
builder.Services.AddFusionCache()
    .WithDefaultEntryOptions(o =>
    {
        o.Duration = TimeSpan.FromMinutes(5);
        o.IsFailSafeEnabled = true;
        o.FailSafeMaxDuration = TimeSpan.FromHours(2);
        o.FactorySoftTimeout = TimeSpan.FromMilliseconds(100);
    });

var product = await cache.GetOrSetAsync(
    $"product:{id}",
    (_, ct) => catalog.GetAsync(id, ct),
    token: ct);
À savoir.NET 9 a ajouté HybridCache (L1 + L2 et protection contre le stampede). FusionCache va plus loin sur la résilience (fail-safe, timeouts, backplane).
Comment écrire des tests fiables sur du code qui dépend de l'heure ou d'un cache ?

On ne lit jamais l'heure directement : on injecte une abstraction du temps, que les tests contrôlent. Depuis .NET 8, c'est TimeProvider, avec FakeTimeProvider pour les tests.

// Code de production : pas de DateTime.Now
public sealed class PromotionService(TimeProvider time)
{
    public bool IsActive(Promotion p) => time.GetUtcNow() < p.EndsAt;
}

// Test : on fixe l'heure, puis on avance le temps
var time = new FakeTimeProvider(new DateTimeOffset(2026, 11, 10, 9, 0, 0, TimeSpan.Zero));
var service = new PromotionService(time);
time.Advance(TimeSpan.FromHours(2));
  • FakeTimeProvider vient du package Microsoft.Extensions.TimeProvider.Testing. Il fait aussi avancer les timers et les Task.Delay qui reçoivent le TimeProvider.
  • Avant .NET 8 : une interface IClock maison, ou NodaTime avec FakeClock.
  • Cache : en test unitaire, on remplace le cache par une implémentation en mémoire neuve à chaque test, ou on le désactive. En test d'intégration, on vide le cache entre les tests pour qu'ils restent indépendants.
  • FusionCache accepte aussi une durée très courte ou une instance dédiée par test pour vérifier l'expiration et le fail-safe.
PiègeUn test qui dépend de l'heure réelle (« passe le matin, échoue à minuit ») ou de l'ordre d'exécution à cause d'un cache partagé est un test instable. Répondre « je ne sais pas » ici coûte cher : c'est une question très classique.

Événementiel, scaling et observabilité

Faire tourner les nouveaux services sur Kubernetes, avec Kafka entre eux.

Qu'est-ce que le scaling ? Comment rendre un service .NET scalable sur Kubernetes ?

Le scaling, c'est adapter la capacité à la charge. Vertical : une machine plus grosse. Horizontal : plus d'instances derrière un load balancer. Sur Kubernetes, on vise l'horizontal.

  • Service stateless : aucun état en mémoire qui doive survivre à une requête (session, panier, cache non partagé). Sinon deux pods répondent différemment.
  • Horizontal Pod Autoscaler (HPA) : Kubernetes ajoute ou retire des pods selon le CPU, la mémoire ou une métrique custom (requêtes par seconde, lag Kafka).
  • Requests / limits CPU et mémoire bien réglés, sondes readiness et liveness (MapHealthChecks).
  • Ressources partagées : la base devient le goulot. Cache, réplicas de lecture, pool de connexions dimensionné pour N pods.
  • Kafka : on ne peut pas avoir plus de consommateurs actifs que de partitions dans un consumer group.
ConseilMême sans l'avoir pratiqué, raisonne à voix haute sur un cas : « un pic d'activité multiplie le trafic par 10, qu'est-ce qui casse en premier ? ». C'est ce que cherche la question.
OpenTelemetry : à quoi ça sert, et comment l'installer dans une API .NET ?

OpenTelemetry est un standard ouvert pour produire les trois signaux d'observabilité (traces, métriques, logs) et les envoyer vers n'importe quel outil, sans dépendre d'un fournisseur.

builder.Services.AddOpenTelemetry()
    .ConfigureResource(r => r.AddService("catalog-api"))
    .WithTracing(t => t
        .AddAspNetCoreInstrumentation()
        .AddHttpClientInstrumentation()
        .AddOtlpExporter())
    .WithMetrics(m => m
        .AddAspNetCoreInstrumentation()
        .AddRuntimeInstrumentation()
        .AddOtlpExporter());
  • Traces : le parcours d'une requête à travers les services (HTTP, Kafka, base), avec la durée de chaque étape.
  • Métriques : latence, débit, erreurs, lag Kafka. Elles alimentent les alertes et l'autoscaling.
  • Logs : corrélés à la trace par le TraceId. On retrouve tous les logs d'une requête en un clic.
  • Export OTLP vers un collector, qui envoie à Elastic, Grafana, Datadog ou Google Cloud Operations.
ConseilSi tu n'as que de l'expérience sur des logs Elasticsearch, dis-le, puis explique ce qu'apportent les traces en plus : savoir quel service a été lent dans une chaîne d'appels, ce que les logs seuls ne montrent pas.
Le catalogue publie un événement Kafka à chaque modification de produit. Quels points faut-il maîtriser ?

Ordre, livraison au moins une fois et cohérence avec la base : ce sont les trois sujets qui reviennent toujours.

  • Ordre : garanti seulement dans une partition. On utilise l'id produit comme clé pour que tous ses événements arrivent dans l'ordre.
  • At-least-once : un message peut être relu après un crash. Les consommateurs doivent être idempotents (table des messages traités, upsert).
  • Cohérence base / Kafka : écrire en base puis publier n'est pas atomique. Pattern Outbox : l'événement est écrit dans la même transaction, puis publié par un processus séparé.
  • Erreurs : retries, puis topic de lettres mortes (DLQ) pour ne pas bloquer la partition.
  • Contrat : schéma versionné (Schema Registry, Avro ou JSON Schema) pour faire évoluer l'événement sans casser les consommateurs.

Revue de code : entraînement

Une petite API ASP.NET Core / EF Core à relire et corriger en direct, sur le domaine fictif de la location de films. Les pièges sont ceux qu'on retrouve dans les exercices de revue de code en RT. Lis le besoin, puis le code, et liste tout ce qui ne va pas avant de déplier.

Le besoinUn service qui enregistre et consulte les films du catalogue. Champs obligatoires : un titre, un réalisateur, un ou plusieurs exemplaires. Un exemplaire contient un support (DVD, Blu-ray), un état et un code-barres. Le service récupère aussi la note d'un film auprès d'un service de notation externe, via un appel POST.
Le code à relire (MoviesController, MovieRecord, Program)
[ApiController]
[Route("api/[controller]")]
public class MoviesController : ControllerBase
{
    private RentalDbContext Db { get; set; }

    public MoviesController(RentalDbContext db)
    {
        Db = new RentalDbContext(new DbContextOptionsBuilder<RentalDbContext>()
            .UseInMemoryDatabase("rental").Options);
    }

    [HttpPost("save")]
    public IActionResult Save(string? code, string? title, string? director)
    {
        var entry = Db.Movies.AddAsync(new MovieRecord { Id = int.Parse(code), title = title }).Result;
        return Ok();
    }

    [HttpGet("{code}")]
    public IActionResult Read(string code)
    {
        var movie = Db.Movies.Where(m => m.Id == int.Parse(code)).SingleOrDefaultAsync().Result;
        return Ok(movie);
    }

    [HttpPost("fetchrating")]
    public IActionResult FetchRating()
    {
        var client = new HttpClient();
        var payload = new StringContent("{ }");
        var result = client.PostAsync(new Uri("ratings-service/v1/ratings"), payload).Result;
        return Ok(result.Content.ReadAsStringAsync().Result);
    }
}

public class MovieRecord
{
    [Key, DatabaseGenerated(DatabaseGeneratedOption.Identity)]
    public int Id { get; set; }
    public string title { get; set; }
    public string Director { get; }
    public object[] Exemplaire { get; set; }
}

// Program.cs : AddDbContext(opt => opt.UseInMemoryDatabase("RentalDb"))
// csproj : net8.0, EF Core 6.0.x, <Nullable>disable</Nullable>
Quels écarts vois-tu entre le besoin et le code ?

Le code ne fait pas ce que le besoin demande : le réalisateur et les exemplaires ne sont jamais enregistrés, et rien n'est validé.

  • director est reçu mais jamais utilisé. Et Director { get; } n'a pas de setter : impossible à affecter, non mappé par EF Core.
  • object[] Exemplaire : pas de type MovieCopy (support, état, code-barres). object[] n'est pas mappable par EF Core, la construction du modèle échoue au premier usage du contexte.
  • Aucune validation : tous les paramètres sont string?, rien n'impose titre, réalisateur et au moins un exemplaire.
  • L'appel de notation n'a aucun lien avec un film : pas d'identifiant en entrée, body vide en dur.
  • Routes avec des verbes (save, fetchrating) : en REST, c'est la méthode HTTP qui porte l'action.
ConseilCommence toujours par relire le besoin à voix haute. Les écarts fonctionnels sont les problèmes les plus graves, et beaucoup de candidats les oublient en se jetant sur les .Result.
Que se passe-t-il quand on appelle le POST d'enregistrement ?

Rien n'est enregistré, et la plupart des entrées invalides donnent une erreur 500.

  • SaveChangesAsync n'est jamais appelé : AddAsync ne fait qu'ajouter l'entité au change tracker.
  • Le contexte injecté est ignoré : le constructeur crée son propre DbContext, sur une base "rental" alors que Program.cs déclare "RentalDb". Ce contexte n'est jamais disposé.
  • Id fourni par le client alors que l'entité est DatabaseGenerated(Identity) : les deux choix se contredisent, un id déjà pris donne une 500.
  • int.Parse(code) sur un string? : null ou non numérique donne une exception, donc une 500 au lieu d'une 400.
  • AddAsync(...).Result : blocage sur de l'asynchrone. Et Add suffit : AddAsync ne sert qu'aux générateurs de valeurs asynchrones.
  • Données en query string sur un POST : on attend un body JSON validé (CreateMovieRequest).
  • Ok() sans corps : pour une création, on attend 201 Created avec l'URL de la ressource (CreatedAtAction).
Et le GET par identifiant ?
  • string code puis int.Parse : un identifiant non numérique donne une 500. Il faut une contrainte de route {id:int} et un paramètre int id, ASP.NET Core renvoie alors 404 tout seul.
  • int.Parse(code) est dans le lambda : on parse une seule fois, en dehors.
  • SingleOrDefaultAsync().Result : même blocage, l'action doit être async.
  • Film introuvable : Ok(null) renvoie un 204 au lieu d'un 404.
  • Pour une recherche par clé, FindAsync(id) est plus simple et profite du cache du contexte.
  • L'entité EF est renvoyée telle quelle : le contrat d'API est couplé au modèle de persistance. Il faut un DTO de réponse.
Que penses-tu de la méthode qui appelle le service externe avec HttpClient ?

Elle plante à chaque appel, et même corrigée, elle épuiserait les sockets en charge. Il faut un client typé injecté, configuré et résilient.

  • new Uri("ratings-service/v1/ratings") : URI relative sans BaseAddress, UriFormatException systématique.
  • new HttpClient() à chaque requête, jamais disposé : épuisement des sockets (TIME_WAIT) et DNS jamais rafraîchi. Il faut IHttpClientFactory ou un client typé (AddHttpClient<T>).
  • URL en dur : elle vient de la configuration (appsettings + IOptions), posée en BaseAddress.
  • Deux .Result : blocage sur de l'asynchrone.
  • Aucun EnsureSuccessStatusCode : une 500 du service externe est renvoyée au client avec un 200.
  • Pas de timeout, de retry, de log ni de CancellationToken.
  • Le body n'a pas de media type JSON, et le JSON brut est renvoyé en string, sans désérialisation dans un modèle.
  • Côté REST : GET /movies/{id}/rating. Le POST vers le service de notation reste un détail interne.
// Program.cs
builder.Services.AddHttpClient<IRatingClient, RatingClient>(c =>
    c.BaseAddress = new Uri(builder.Configuration["RatingApi:BaseUrl"]!))
    .AddStandardResilienceHandler(); // retries, timeouts, circuit breaker

// Client typé
public sealed class RatingClient(HttpClient http) : IRatingClient
{
    public async Task<MovieRating?> GetAsync(int movieId, CancellationToken ct)
    {
        using var response = await http.PostAsJsonAsync("ratings", new { movieId }, ct);
        if (response.StatusCode == HttpStatusCode.NotFound) return null;
        response.EnsureSuccessStatusCode();
        return await response.Content.ReadFromJsonAsync<MovieRating>(ct);
    }
}
PiègeC'est souvent la dernière question de la séance, faite dans l'urgence. Si tu dois choisir, cite d'abord l'URI invalide et IHttpClientFactory, puis la gestion des erreurs du service externe.
Pourquoi .Result est-il dangereux ? Le risque est-il le même sur le legacy .NET Framework et sur .NET 10 ?

Non. Sur ASP.NET classique (.NET Framework), .Result peut provoquer un deadlock. Sur ASP.NET Core, pas de deadlock, mais un thread bloqué par requête, ce qui mène à la famine du thread pool sous charge.

  • .NET Framework : ASP.NET classique a un SynchronizationContext qui n'autorise qu'un thread à la fois par requête. Le thread bloqué sur .Result attend une continuation qui doit reprendre sur ce même contexte : deadlock.
  • ASP.NET Core : pas de SynchronizationContext, la continuation reprend sur un autre thread. Mais chaque requête immobilise un thread pendant l'attente ; en pic de trafic, le pool sature et les temps de réponse explosent.
  • Les exceptions sont enveloppées dans une AggregateException, ce qui complique leur gestion.
  • Correction : async / await de bout en bout, jusqu'au contrôleur, avec un CancellationToken.
Lien avec la missionLe legacy est en .NET Framework 4.7 : le cas du deadlock y est réel. Le dire montre que tu relies l'exercice au contexte du client. Pour approfondir : la formation Async et threads .NET.
Comment centraliser la gestion des erreurs et renvoyer les bons codes HTTP ?

Les cas attendus (validation, introuvable) se traitent dans l'action avec le bon code. Les exceptions imprévues passent par un gestionnaire unique qui renvoie un ProblemDetails (RFC 9457).

builder.Services.AddProblemDetails();
builder.Services.AddExceptionHandler<UpstreamExceptionHandler>();
app.UseExceptionHandler();

public sealed class UpstreamExceptionHandler(IProblemDetailsService problems) : IExceptionHandler
{
    public async ValueTask<bool> TryHandleAsync(HttpContext ctx, Exception ex, CancellationToken ct)
    {
        if (ex is not HttpRequestException) return false;
        ctx.Response.StatusCode = StatusCodes.Status502BadGateway;
        return await problems.TryWriteAsync(new() { HttpContext = ctx, Exception = ex });
    }
}
CasCode
Body invalide, champ obligatoire manquant400 (automatique avec [ApiController])
Film introuvable404
Création réussie201 + header Location
Service externe en erreur ou injoignable502 / 503 / 504
Bug imprévu500, sans stack trace exposée
PiègeNe pas utiliser les exceptions pour le flux normal (« introuvable » n'est pas exceptionnel). Le middleware sert de filet, pas de logique métier.
Au-delà des bugs : qu'est-ce qui manque côté architecture et projet ?
  • Aucune séparation des couches : le contrôleur parle directement au DbContext et à HttpClient. Il manque une couche service, ce qui rend le code intestable en unitaire.
  • Aucun DTO d'entrée ni de sortie.
  • Aucun test.
  • Base InMemory : acceptable en démo, pas en production (ni contraintes, ni transactions, ni migrations).
  • Sécurité : UseAuthorization() sans authentification ni [Authorize] : n'importe qui peut écrire dans le catalogue.
  • Dépendances : EF Core 6 (plus supporté) sur net8.0, à aligner en 8.x.
  • Nullable désactivé alors que le code utilise string? (warning CS8632).
  • Style : propriété Db { get; set; } au lieu d'un champ private readonly, title en minuscule, Exemplaire en français et au singulier pour une collection, suffixe Record flou.
Comment testerais-tu ce service une fois corrigé ?
  • Unitaires : la validation (titre, réalisateur, au moins un exemplaire), le service avec un faux IRatingClient.
  • Intégration : WebApplicationFactory + une vraie base (Testcontainers SQL Server) pour POST puis GET, 404, 400.
  • Client HTTP : un HttpMessageHandler factice (ou WireMock.Net) pour simuler 200, 404, 500 et timeout du service externe.
  • Snapshot : Verify sur la réponse JSON pour figer le contrat.

Améliorations à faire, dans l'ordre

En live, on n'a pas le temps de tout corriger. Annonce ce plan, puis avance du plus grave au plus cosmétique.

Dans quel ordre corriges-tu, si tu n'as que 20 minutes ?
OrdreAméliorationPourquoi d'abord
1Utiliser le DbContext injecté et appeler SaveChangesAsyncSans ça, rien n'est enregistré
2Modèle Movie + MovieCopy, réalisateur enregistré, Id généré par la baseLe besoin n'est pas respecté
3DTO CreateMovieRequest validé, en body JSONEntrées invalides en 500, données dans l'URL
4async / await partout, CancellationTokenFamine de threads en charge
5Routes REST et codes HTTP : 201, 404, {id:int}Contrat d'API exploitable par les clients
6Client HTTP typé, URL en configuration, EnsureSuccessStatusCode, résiliencePlante à chaque appel, sockets épuisés
7Couche service, gestionnaire d'exceptions, testsTestabilité et maintenabilité
8EF Core 8, nullable activé, authentification, nommageDette et sécurité
À quoi ressemble une version corrigée ?
// Domaine
public sealed class Movie
{
    public int Id { get; private set; }
    public required string Title { get; init; }
    public required string Director { get; init; }
    public List<MovieCopy> Copies { get; init; } = [];
}

public sealed record MovieCopy(MediaType Media, CopyCondition Condition, string Barcode);

// DbContext : modelBuilder.Entity<Movie>().OwnsMany(m => m.Copies);

// Contrat d'API
public sealed record CreateMovieRequest(
    [Required] string Title,
    [Required] string Director,
    [Required, MinLength(1)] List<MovieCopyDto> Copies);

public sealed record MovieCopyDto(MediaType Media, CopyCondition Condition, [Required] string Barcode);

// Contrôleur
[ApiController]
[Route("movies")]
public sealed class MoviesController(IMovieService movies) : ControllerBase
{
    [HttpPost]
    public async Task<ActionResult<MovieResponse>> Create(CreateMovieRequest request, CancellationToken ct)
    {
        var movie = await movies.CreateAsync(request, ct);
        return CreatedAtAction(nameof(Get), new { id = movie.Id }, movie);
    }

    [HttpGet("{id:int}")]
    public async Task<ActionResult<MovieResponse>> Get(int id, CancellationToken ct)
    {
        var movie = await movies.GetAsync(id, ct);
        if (movie is null) return NotFound();
        return movie;
    }

    [HttpGet("{id:int}/rating")]
    public async Task<ActionResult<MovieRating>> GetRating(int id, CancellationToken ct)
    {
        var rating = await movies.GetRatingAsync(id, ct);
        if (rating is null) return NotFound();
        return rating;
    }
}
  • Le service (IMovieService) mappe le DTO vers l'entité, appelle SaveChangesAsync et renvoie un MovieResponse.
  • Le client typé IRatingClient est celui de la question sur HttpClient.
  • Pour aller plus loin : Barcode en Value Object, validé à la construction.