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.
| Sujet | Legacy | Cible |
|---|---|---|
| Runtime | .NET Framework 4.7, Azure DevOps | .NET 10, GitLab |
| Données | SQL Server monolithique, plusieurs centaines de tables | Données découpées par domaine (catalogue en premier) |
| Migration | — | Strangler Fig avec dual run ancien / nouveau |
| Architecture | Monolithe | Clean Architecture, pattern Mediator, Kafka |
| Performance | — | Cache (FusionCache, fail-safe) |
| Tests | — | Unitaires, intégration, snapshot |
| Infra et run | Logs Elasticsearch | GCP, 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
.verifiedet 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);
}
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.
- Façade : un reverse proxy (YARP, API gateway, ingress) reçoit tout le trafic et le route vers l'ancien par défaut.
- Découpage : on choisit un périmètre cohérent et peu couplé, ici le catalogue.
- Dual run : le nouveau service reçoit une copie du trafic (shadow). On compare les réponses, on corrige les écarts, sans impact client.
- Bascule progressive : feature flag ou pourcentage de trafic, avec retour arrière immédiat possible.
- 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.
- Décommission : on supprime le code legacy du périmètre une fois la bascule stabilisée.
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é.
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 Id | Mêmes valeurs |
| Cycle de vie | Évolue dans le temps | Immuable : on le remplace |
| Exemples | Commande, Client, Produit | Prix + 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
PostalCodeexistant est forcément valide. Fini lesstringvérifiées partout (« primitive obsession »). - Un
recordC# donne l'égalité par valeur gratuitement. - Avec EF Core :
OwnsOne/OwnsMany, ouComplexPropertydepuis EF Core 8.
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), classessealed. - Analyseurs Roslyn et
.editorconfig: règles de style en erreur de build. - Revue de code : reste utile pour le reste (lisibilité, choix de conception).
À 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.
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);
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));
FakeTimeProvidervient du packageMicrosoft.Extensions.TimeProvider.Testing. Il fait aussi avancer les timers et lesTask.Delayqui reçoivent leTimeProvider.- Avant .NET 8 : une interface
IClockmaison, ou NodaTime avecFakeClock. - 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.
É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
readinessetliveness(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.
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.
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 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é.
directorest reçu mais jamais utilisé. EtDirector { get; }n'a pas de setter : impossible à affecter, non mappé par EF Core.object[] Exemplaire: pas de typeMovieCopy(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.
.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.
SaveChangesAsyncn'est jamais appelé :AddAsyncne 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 queProgram.csdé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 unstring?:nullou non numérique donne une exception, donc une 500 au lieu d'une 400.AddAsync(...).Result: blocage sur de l'asynchrone. EtAddsuffit :AddAsyncne 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 attend201 Createdavec l'URL de la ressource (CreatedAtAction).
Et le GET par identifiant ?
string codepuisint.Parse: un identifiant non numérique donne une 500. Il faut une contrainte de route{id:int}et un paramètreint 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 êtreasync.- 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 sansBaseAddress,UriFormatExceptionsystématique.new HttpClient()à chaque requête, jamais disposé : épuisement des sockets (TIME_WAIT) et DNS jamais rafraîchi. Il fautIHttpClientFactoryou un client typé (AddHttpClient<T>).- URL en dur : elle vient de la configuration (
appsettings+IOptions), posée enBaseAddress. - 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);
}
}
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
SynchronizationContextqui n'autorise qu'un thread à la fois par requête. Le thread bloqué sur.Resultattend 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/awaitde bout en bout, jusqu'au contrôleur, avec unCancellationToken.
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 });
}
}
| Cas | Code |
|---|---|
| Body invalide, champ obligatoire manquant | 400 (automatique avec [ApiController]) |
| Film introuvable | 404 |
| Création réussie | 201 + header Location |
| Service externe en erreur ou injoignable | 502 / 503 / 504 |
| Bug imprévu | 500, sans stack trace exposée |
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
DbContextet à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 champprivate readonly,titleen minuscule,Exemplaireen français et au singulier pour une collection, suffixeRecordflou.
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
HttpMessageHandlerfactice (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 ?
| Ordre | Amélioration | Pourquoi d'abord |
|---|---|---|
| 1 | Utiliser le DbContext injecté et appeler SaveChangesAsync | Sans ça, rien n'est enregistré |
| 2 | Modèle Movie + MovieCopy, réalisateur enregistré, Id généré par la base | Le besoin n'est pas respecté |
| 3 | DTO CreateMovieRequest validé, en body JSON | Entrées invalides en 500, données dans l'URL |
| 4 | async / await partout, CancellationToken | Famine de threads en charge |
| 5 | Routes REST et codes HTTP : 201, 404, {id:int} | Contrat d'API exploitable par les clients |
| 6 | Client HTTP typé, URL en configuration, EnsureSuccessStatusCode, résilience | Plante à chaque appel, sockets épuisés |
| 7 | Couche service, gestionnaire d'exceptions, tests | Testabilité et maintenabilité |
| 8 | EF Core 8, nullable activé, authentification, nommage | Dette 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é, appelleSaveChangesAsyncet renvoie unMovieResponse. - Le client typé
IRatingClientest celui de la question surHttpClient. - Pour aller plus loin :
Barcodeen Value Object, validé à la construction.
Aucune question ne correspond. Modifie ta recherche ou ton filtre.