Parcours & environnement technique
Des exemples de questions pour démarrer l'échange sur ton parcours. À toi de préparer tes réponses à partir de ton expérience.
- Depuis combien de temps fais-tu du développement .NET, et sur quels types de projets ?
- Quelle expérience as-tu de .NET Framework et de .NET moderne ?
- As-tu déjà travaillé avec des Web Services SOAP ou WCF ?
- As-tu travaillé sur des applications à forte charge ? Quels problèmes de performance, de concurrence ou de scalabilité as-tu rencontrés ?
- Quelles bases de données as-tu utilisées, et dans quel contexte ?
- Peux-tu présenter un projet dans lequel SQL tenait une place importante ?
- Comment accèdes-tu aux données : ORM comme Entity Framework, procédures stockées, requêtes SQL ?
- Sur quels environnements as-tu déployé tes applications : serveurs, cloud, conteneurs ?
- As-tu participé à une migration vers le cloud ? Quel était ton rôle ?
Questions .NET
Pendant la review, tu ouvres ton rendu et tu partages ton écran : garde le projet prêt à compiler sur ton poste. Les questions partent souvent de ton code pour aller vers des notions plus générales.
Comment tracer l'entrée et la sortie de chaque méthode ou de chaque requête sans dupliquer le code de log partout ?
Le logging est une préoccupation transverse. On le sort du code métier pour le placer à un seul endroit du pipeline.
- Middleware ASP.NET Core : log de chaque requête HTTP (méthode, route, statut, durée). Existe déjà :
app.UseHttpLogging()ouUseSerilogRequestLogging(). - Action filter (
IAsyncActionFilter) : log au niveau des actions de contrôleur, avec accès aux arguments. - Pipeline Behavior MediatR (si le projet utilise MediatR) : enveloppe chaque handler, comme un middleware.
- Décorateur sur l'interface d'un service (
LoggingRentalService : IRentalService), enregistré avec Scrutorservices.Decorate<…>().
public sealed class RequestLoggingMiddleware(RequestDelegate next, ILogger<RequestLoggingMiddleware> logger)
{
public async Task InvokeAsync(HttpContext context)
{
var sw = Stopwatch.StartNew();
await next(context);
logger.LogInformation("{Method} {Path} → {StatusCode} en {Elapsed} ms",
context.Request.Method, context.Request.Path,
context.Response.StatusCode, sw.ElapsedMilliseconds);
}
}
"{MovieId}") et non de l'interpolation ($"{movieId}") : sinon les propriétés ne sont plus filtrables dans Datadog et le message est construit même si le niveau de log est désactivé.À quoi sert un CancellationToken dans une API ASP.NET Core ? Suffit-il de l'ajouter en paramètre d'une méthode ?
Un CancellationToken permet d'annuler proprement un traitement en cours, par exemple quand le client HTTP ferme la connexion ou quand un timeout est atteint. Il ne sert que s'il est propagé jusqu'aux opérations asynchrones.
- Dans une action de contrôleur, ASP.NET Core lie automatiquement le paramètre à
HttpContext.RequestAborted. - Il faut le passer à toute la chaîne : service → repository →
ToListAsync(ct),HttpClient.GetAsync(url, ct),Task.Delay(…, ct). Sinon il est inutile. - Bénéfice : on libère la connexion SQL et le thread dès que le client abandonne, au lieu de finir une requête coûteuse que personne ne lira. Sous forte charge, ça compte.
- Dans une boucle longue :
cancellationToken.ThrowIfCancellationRequested(). - Sur une écriture (ajout d'un film) : on vérifie le token avant de commencer et on le passe aux appels asynchrones de lecture (contrôle de doublon). Une fois l'écriture validée en base, on ne cherche plus à annuler : l'opération est faite, autant renvoyer la réponse.
[HttpGet("movies")]
public async Task<IActionResult> GetAllMovies(CancellationToken cancellationToken)
{
var movies = await _rentalService.GetAllMoviesAsync(cancellationToken);
return Ok(movies);
}
// Repository EF Core
public Task<List<Movie>> GetAllAsync(CancellationToken ct) =>
_db.Movies.AsNoTracking().ToListAsync(ct);
Qu'est-ce qu'un middleware en ASP.NET Core ? À quoi sert un middleware de gestion des exceptions ?
Un middleware est un maillon du pipeline HTTP : il reçoit la requête, peut agir avant et après l'appel au suivant (await next(context)), ou court-circuiter la chaîne. L'ordre d'enregistrement dans Program.cs est l'ordre d'exécution.
Un middleware de gestion des exceptions, placé en tête du pipeline, centralise la transformation des exceptions en réponses HTTP cohérentes : plus besoin de try/catch dans chaque action, le log est fait une seule fois et aucune stack trace ne fuit vers le client.
- Mappe les exceptions métier vers les bons statuts :
DuplicateMovieException→ 409 Conflict,InvalidMovieTitleException→ 400, non trouvé → 404, le reste → 500. - Répond au format standard
ProblemDetails(RFC 9457) :type,title,status,detail,traceId. - En .NET 8 :
IExceptionHandler+services.AddProblemDetails()+app.UseExceptionHandler().
public sealed class RentalExceptionHandler(ILogger<RentalExceptionHandler> logger) : IExceptionHandler
{
public async ValueTask<bool> TryHandleAsync(HttpContext ctx, Exception ex, CancellationToken ct)
{
var (status, title) = ex switch
{
DuplicateMovieException => (StatusCodes.Status409Conflict, "Film déjà existant"),
InvalidMovieTitleException => (StatusCodes.Status400BadRequest, "Titre invalide"),
_ => (StatusCodes.Status500InternalServerError, "Erreur interne")
};
if (status == 500) logger.LogError(ex, "Erreur non gérée");
ctx.Response.StatusCode = status;
await ctx.Response.WriteAsJsonAsync(new ProblemDetails { Status = status, Title = title }, ct);
return true;
}
}
Result<T>, OneOf, ErrorOr).Thread safety, repository et montée en charge
On part d'un repository qui stocke ses données dans une liste en mémoire, puis on imagine une vraie API en production.
Un repository stocke ses données dans une List<T> et est enregistré en Singleton. Est-il thread-safe ?
Non. Le repository est enregistré en Singleton : la même List<Movie> est partagée par toutes les requêtes HTTP, qui s'exécutent en parallèle.
List<T>n'est pas thread-safe : deuxAddsimultanés peuvent corrompre la liste ou perdre un élément.- Check-then-act : si on vérifie les doublons (
Any(...)) avant d'ajouter, les deux étapes ne sont pas atomiques. Deux requêtes identiques passent le contrôle en même temps et le film est ajouté deux fois. - Génération d'ID du type
Max(m => m.Id) + 1: deux requêtes calculent le même ID. GetAll()renvoieAsReadOnly(), une simple vue sur la liste vivante. Énumérer pendant un ajout lèveInvalidOperationException: Collection was modified.
Comment rendre un repository en mémoire thread-safe ? Qu'est-ce qui est réellement protégé ?
Un lock autour de l'ajout et de la lecture : l'ensemble « vérifier, générer l'ID, ajouter » devient atomique et la collection interne n'est jamais exposée.
public sealed class InMemoryMovieRepository : IMovieRepository
{
private readonly List<Movie> _movies = [];
private readonly object _sync = new();
public IReadOnlyCollection<Movie> GetAll()
{
lock (_sync) return _movies.ToList(); // copie : pas de lecture pendant une écriture
}
public Movie Add(string title, string director)
{
lock (_sync)
{
if (_movies.Any(m => m.Title == title && m.Director == director))
throw new DuplicateMovieException();
var id = _movies.Count == 0 ? 1 : _movies.Max(m => m.Id) + 1;
var movie = new Movie(id, title, true, director);
_movies.Add(movie);
return movie;
}
}
}
- Le
lockgarantit qu'un seul thread à la fois exécute le bloc : la vérification du doublon, le calcul de l'ID et l'ajout deviennent une seule opération atomique. - Les lectures passent aussi par le
locket renvoient une copie, pour ne jamais énumérer la liste pendant qu'un autre thread y ajoute un élément. - On verrouille sur un objet privé dédié (
_sync), jamais surthisni sur la liste exposée. - On garde la section critique courte : pas d'appel réseau ni d'I/O à l'intérieur. On ne peut pas non plus faire d'
awaitdans unlock.
Ce que le lock protège exactement : uniquement le code placé à l'intérieur d'un bloc qui verrouille le même objet. Trois cas où la méthode reste non thread-safe malgré le lock :
- L'objet de verrou n'est pas partagé. Un
_syncdéclaré dans un service enregistré enScopedouTransientest différent à chaque requête : chaque requête a son propre verrou, qui ne bloque personne. Le verrou doit vivre au même niveau que les données (repository Singleton) ou êtrestatic. - Une partie de l'accès reste hors du verrou : si
GetAlllit la liste sanslockpendant qu'un ajout a lieu, l'énumération peut planter. - La vérification et l'ajout sont dans deux verrous séparés : chaque étape est protégée, mais deux requêtes peuvent s'intercaler entre les deux. C'est toute la séquence qui doit être dans le même bloc.
lock ne protège qu'un seul processus. Avec plusieurs instances de l'API, il ne sert plus à rien : c'est la base de données qui doit garantir l'unicité (question suivante).Une API qui garde ses données en mémoire doit passer sur plusieurs instances. Quelles évolutions faut-il prévoir ?
Chaque instance aurait sa propre liste : les données divergent et sont perdues au redémarrage. Il faut rendre l'API sans état et déplacer l'état et les garanties d'unicité vers la base.
- Persistance : SQL Server via EF Core ou Dapper, repository en
Scoped(unDbContextpar requête). - ID générés par la base (
IDENTITYouSEQUENCE), plus deMax + 1. - Unicité garantie par un index unique
(DirectorId, Title). On intercepte l'erreur SQL 2601/2627 et on renvoie 409. Le contrôle applicatif reste utile pour un message clair, mais la base fait foi. - Concurrence : verrouillage optimiste avec
rowversionsur les mises à jour (ex. location d'un film disponible). - Async de bout en bout +
CancellationToken. - Cache : pas de cache mémoire local incohérent entre instances. Utiliser un cache distribué (Redis) avec invalidation, ou accepter une expiration courte.
- Idempotence des POST (clé d'idempotence) pour gérer les retries du load balancer ou du client.
- Exploitabilité : health checks (
/health) pour les probes Kubernetes, configuration externalisée, Correlation ID, logs centralisés. - Verrou distribué (
sp_getapplock, Redis) seulement si un traitement doit vraiment être exclusif entre instances.
Scoped est recréé à chaque requête : ses données disparaissent d'une requête à l'autre. Savoir expliquer les durées de vie (Singleton, Scoped, Transient) et la « captive dependency » est attendu.Pour vérifier qu'un élément existe déjà, faut-il charger toutes les données ? Quelles alternatives ?
Non. Avec 300 millions de films, charger toute la table pour vérifier un doublon ou calculer un ID ferait exploser la mémoire, le réseau et le temps de réponse. On délègue le filtre à la base avec une requête ciblée.
// Approche naïve : tout charger puis filtrer en mémoire
var allMovies = _movieRepository.GetAll();
if (allMovies.Any(m => m.Title == title && m.Director == director)) ...
// Mieux : une requête EXISTS côté SQL
public Task<bool> ExistsAsync(string title, int directorId, CancellationToken ct) =>
_db.Movies.AnyAsync(m => m.Title == title && m.DirectorId == directorId, ct);
- Paginer puis boucler ne règle rien : on ne charge plus tout d'un coup, mais on enchaîne des centaines de milliers de requêtes pour parcourir la table et tout passe quand même sur le réseau. Le problème n'est pas la taille du lot, c'est de rapatrier des données dont on n'a pas besoin.
- La bonne approche : poser la question exacte à la base. « Existe-t-il un film avec ce titre et ce réalisateur ? » se traduit par un
EXISTSqui renvoie un booléen en une seule requête. - La pagination sert à afficher une liste à un utilisateur (
OFFSET … FETCH, ou pagination par clé pour les gros volumes), pas à faire une vérification. - Un index sur
(DirectorId, Title)rend leEXISTSinstantané. - Éviter de faire fuiter
IQueryablehors du repository : exposer des méthodes à intention claire.
Avec une base SQL Server volumineuse, comment organiser les validations avant un ajout (valeurs obligatoires, doublons) ?
Du moins cher au plus cher : d'abord les contrôles en mémoire, puis une requête ciblée, et la base comme dernier garde-fou.
- Valeurs obligatoires, en mémoire : non nulles, pas uniquement des espaces, longueur minimale. Aucun accès à la base : si la requête est invalide, on répond 400 tout de suite.
- Doublon, requête ciblée : un
EXISTSsur titre et réalisateur, appuyé sur un index. Il permet de renvoyer un message clair (409). - Contrainte d'unicité en base : index unique
(DirectorId, Title). Entre leEXISTSet l'INSERT, une autre requête peut insérer le même film. Seule la base garantit l'unicité : on intercepte l'erreur 2601/2627 et on renvoie aussi 409.
-- Vérification ciblée (index sur DirectorId, Title)
SELECT CASE WHEN EXISTS (
SELECT 1 FROM dbo.Movie WHERE DirectorId = @DirectorId AND Title = @Title
) THEN 1 ELSE 0 END;
-- Garde-fou ultime
CREATE UNIQUE INDEX UX_Movie_Director_Title ON dbo.Movie (DirectorId, Title);
- Variante assumée : ne pas faire le
EXISTSet tenter directement l'INSERT, en traduisant la violation de contrainte en 409. Une seule requête, et pas de fenêtre de concurrence. - Penser à la normalisation : faut-il considérer « Movie 1 » et « movie 1 » comme identiques ? La collation de la colonne (sensible ou non à la casse) répond à la question côté base.
Comment faire évoluer un repository en mémoire vers une vraie persistance ?
L'interface reste dans le Domain, l'implémentation SQL arrive dans l'Infrastructure. Le reste du code ne change presque pas : c'est l'intérêt du pattern.
- Nouvelle implémentation
SqlMovieRepository : IMovieRepository, enregistrée enScopedà la place de l'implémentation en mémoire. - Signatures asynchrones avec
CancellationToken:Task<Movie?> GetByIdAsync(int id, CancellationToken ct). - Méthodes à intention claire (
ExistsAsync,GetPageAsync) plutôt qu'unGetAllgénérique. - L'ID n'est plus fourni par le service : c'est la base qui le génère, le repository le renvoie après l'insert.
- Gestion des transactions quand plusieurs écritures doivent être atomiques (Unit of Work ;
DbContext.SaveChangesAsyncen est déjà un). - Mapping entité de domaine ↔ modèle de persistance si l'entité a des propriétés en lecture seule (EF Core sait mapper des champs privés et des constructeurs).
Modélisation de la base de données
On imagine que les données doivent être persistées dans une base relationnelle de type SQL Server.
Quelles tables et quelles colonnes prévoir pour une plateforme de location de films ?
Trois tables au minimum : Customer, Movie et une table de locations Rental qui relie les deux. Une table Director est un plus.
CREATE TABLE dbo.Director (
Id INT IDENTITY(1,1) CONSTRAINT PK_Director PRIMARY KEY,
Name NVARCHAR(200) NOT NULL
);
CREATE TABLE dbo.Movie (
Id INT IDENTITY(1,1) CONSTRAINT PK_Movie PRIMARY KEY,
Title NVARCHAR(200) NOT NULL,
DirectorId INT NOT NULL CONSTRAINT FK_Movie_Director REFERENCES dbo.Director(Id),
CreatedAt DATETIME2 NOT NULL DEFAULT SYSUTCDATETIME(),
CONSTRAINT UQ_Movie_Director_Title UNIQUE (DirectorId, Title)
);
CREATE TABLE dbo.Customer (
Id INT IDENTITY(1,1) CONSTRAINT PK_Customer PRIMARY KEY,
Name NVARCHAR(200) NOT NULL,
DateOfBirth DATE NOT NULL
);
CREATE TABLE dbo.Rental (
Id BIGINT IDENTITY(1,1) CONSTRAINT PK_Rental PRIMARY KEY,
CustomerId INT NOT NULL CONSTRAINT FK_Rental_Customer REFERENCES dbo.Customer(Id),
MovieId INT NOT NULL CONSTRAINT FK_Rental_Movie REFERENCES dbo.Movie(Id),
RentedAt DATETIME2 NOT NULL,
DueAt DATETIME2 NULL,
ReturnedAt DATETIME2 NULL -- NULL = location en cours
);
CREATE INDEX IX_Rental_MovieId ON dbo.Rental (MovieId);
CREATE INDEX IX_Rental_CustomerId ON dbo.Rental (CustomerId);
- Les clés étrangères ne sont pas indexées automatiquement dans SQL Server : on crée les index soi-même.
IsAvailablepeut être déduit (aucune location avecReturnedAt IS NULL) plutôt que stocké, ce qui évite les incohérences. Si on le stocke pour la performance, il faut le maintenir dans la même transaction.
Comment modéliser la relation entre un client et les films qu'il loue ? Quelles informations stocker ?
C'est une relation plusieurs-à-plusieurs, portée par une table d'association qui est aussi un historique : une ligne par location.
CustomerIdetMovieIden clés étrangères.- Les dates :
RentedAt,DueAt(date de retour prévue),ReturnedAt(nullable). - Une clé primaire propre (
Id) et non la clé composite(CustomerId, MovieId): un même client peut louer le même film plusieurs fois. - Éventuellement : statut, pénalité de retard, agent ou canal de location.
Customer. En base, on ne stocke pas de liste dans une colonne : on normalise dans une table dédiée.ID interne auto-incrémenté ou identifiant public : que choisis-tu et pourquoi ?
Les deux : un ID interne INT IDENTITY pour les jointures et l'index clustered, et un identifiant public (GUID) exposé dans l'API.
- ID interne entier : compact (4 ou 8 octets), séquentiel, idéal comme clé clustered et pour les jointures.
- Identifiant public : n'expose pas le volume de données ni un ID devinable (
/movies/42→ on essaie/movies/43). Il permet aussi de générer l'identifiant côté client ou d'un autre système. - Un GUID aléatoire (
NEWID()) en clé clustered fragmente l'index. PréférerNEWSEQUENTIALID()ou garder le GUID en colonne non clustered avec un index unique.
Si la base de données ne fournit pas d'auto-incrément, comment générer les identifiants ? Quelles solutions envisagerais-tu ?
Plusieurs solutions existent ; l'important est de citer leurs compromis et d'écarter le MAX(Id) + 1, qui n'est pas sûr en concurrence.
| Solution | Principe | Compromis |
|---|---|---|
| GUID / UUID | Généré côté application (Guid.NewGuid()), unique sans coordination | 16 octets, non séquentiel : fragmente un index clustered. Préférer une version ordonnée dans le temps (UUID v7, Guid.CreateVersion7() en .NET 9) |
| Séquence | Objet SEQUENCE de la base, interrogé avant l'insert (NEXT VALUE FOR) | Un aller-retour par ID, sauf à réserver des plages |
| HiLo | L'application réserve une plage d'ID (ex. 100) auprès de la base, puis les distribue en mémoire (UseHiLo() avec EF Core) | Peu d'allers-retours ; des trous dans la numérotation |
| Table de compteurs | Une ligne par entité, incrémentée de façon atomique : UPDATE … SET @id = Value = Value + 1 | Simple, mais point de contention si beaucoup d'insertions |
| Compteur externe | INCR Redis, atomique | Une dépendance de plus à exploiter |
| Snowflake | ID 64 bits composé de l'horodatage, d'un identifiant de machine et d'un compteur local | Trié dans le temps, sans coordination ; dépend de l'horloge des machines |
SELECT MAX(Id) + 1 puis INSERT : deux requêtes simultanées obtiennent le même ID. C'est le même problème de « vérifier puis agir » que pour les doublons.Exercices SQL sans IDE
Requêtes à écrire sans IDE ni exécution. Modèle : Customer(Id, Name, DateOfBirth NOT NULL), Director(Id, Name), Movie(Id, Title, DirectorId), Rentals(CustomerId, MovieId, RentedAt). Chaque ligne de Rentals est une location : un film loué trois fois apparaît trois fois.
Écris une requête qui renvoie les 5 réalisateurs dont les films cumulent le plus de locations, avec ce nombre de locations.
Deux jointures (réalisateur → films → locations), regroupement par réalisateur, comptage, tri décroissant, TOP (5).
SELECT TOP (5)
d.Id,
d.Name,
COUNT(*) AS NbLocations
FROM dbo.Director d
JOIN dbo.Movie m ON m.DirectorId = d.Id
JOIN dbo.Rentals r ON r.MovieId = m.Id
GROUP BY d.Id, d.Name
ORDER BY NbLocations DESC;
- Comment compter ? Après les deux jointures, il y a une ligne par location.
COUNT(*)sur chaque groupe « réalisateur » donne le total de ses locations, tous films confondus.COUNT(1)est strictement équivalent. - Comment ordonner ?
ORDER BY NbLocations DESC. L'alias duSELECTest utilisable dans l'ORDER BY, car celui-ci est évalué après. - Toute colonne du
SELECTqui n'est pas agrégée doit figurer dans leGROUP BY: icid.Idetd.Name. Regrouper aussi par film donnerait un total par film, pas par réalisateur. - Ex æquo au 5ᵉ rang :
SELECT TOP (5) WITH TIESles inclut. - Pour inclure les réalisateurs sans aucune location :
LEFT JOINsur les deux tables etCOUNT(r.MovieId), qui ne compte pas lesNULL.
GROUP BY, regrouper au mauvais niveau (par film au lieu de par réalisateur), ou utiliser un alias qui n'existe pas (dr.Name au lieu de d.Name). Sans IDE, relis tes alias.Peut-on utiliser un ORDER BY dans une sous-requête ?
En SQL Server, non, sauf si la sous-requête contient aussi TOP, OFFSET … FETCH ou FOR XML. Sinon : erreur 1033.
- Raison : une sous-requête (ou une vue, une CTE) est un ensemble, donc sans ordre. Seul l'
ORDER BYde la requête la plus externe garantit l'ordre du résultat. - Avec
TOP, l'ORDER BYest accepté car il sert à choisir quelles lignes garder, pas à ordonner le résultat final.
-- Refusé (erreur 1033)
SELECT * FROM (SELECT MovieId FROM dbo.Rentals ORDER BY MovieId) t;
-- Accepté : le ORDER BY sert au TOP
SELECT * FROM (SELECT TOP (5) MovieId FROM dbo.Rentals ORDER BY RentedAt DESC) t;
Écris une requête qui renvoie l'ID et le nom du client le plus âgé ayant loué au moins 3 films différents.
On regroupe les locations par client, on garde ceux qui ont loué au moins 3 films distincts avec HAVING COUNT(DISTINCT …), puis on trie par date de naissance croissante : le plus âgé est celui né le plus tôt.
SELECT TOP (1)
c.Id,
c.Name
FROM dbo.Customer c
JOIN dbo.Rentals r ON r.CustomerId = c.Id
GROUP BY c.Id, c.Name, c.DateOfBirth
HAVING COUNT(DISTINCT r.MovieId) >= 3
ORDER BY c.DateOfBirth ASC;
Variante avec une CTE, souvent plus lisible à l'oral :
WITH Eligibles AS (
SELECT CustomerId
FROM dbo.Rentals
GROUP BY CustomerId
HAVING COUNT(DISTINCT MovieId) >= 3
)
SELECT TOP (1) WITH TIES c.Id, c.Name
FROM dbo.Customer c
JOIN Eligibles e ON e.CustomerId = c.Id
ORDER BY c.DateOfBirth;
MIN(DateOfBirth) ou ORDER BY DateOfBirth ASC. Inverser le tri renvoie le plus jeune : c'est une erreur fréquente, relis toujours le sens du tri.COUNT(*) compterait les locations ; il faut COUNT(DISTINCT r.MovieId).Quelle est la différence entre WHERE et HAVING ? Dans quel ordre une requête est-elle évaluée ?
WHERE filtre les lignes avant le regroupement. HAVING filtre les groupes après, et c'est le seul endroit où on peut filtrer sur un agrégat (COUNT, SUM, MAX…).
Ordre logique d'évaluation d'une requête, à connaître par cœur :
| Étape | Clause | Rôle |
|---|---|---|
| 1 | FROM / JOIN | Construire l'ensemble de lignes |
| 2 | WHERE | Filtrer les lignes (pas d'agrégat possible) |
| 3 | GROUP BY | Former les groupes |
| 4 | HAVING | Filtrer les groupes (agrégats autorisés) |
| 5 | SELECT | Calculer les colonnes et les alias |
| 6 | ORDER BY | Trier (les alias du SELECT sont visibles) |
| 7 | TOP / OFFSET | Limiter le résultat |
-- Locations depuis 2024 (WHERE), clients avec au moins 5 locations (HAVING)
SELECT CustomerId, COUNT(*) AS Nb
FROM dbo.Rentals
WHERE RentedAt >= '2024-01-01'
GROUP BY CustomerId
HAVING COUNT(*) >= 5;
Peut-on utiliser une fonction d'agrégat comme MIN() ou MAX() dans un WHERE ? Sinon, comment faire ?
Non. Un agrégat ne peut pas apparaître dans un WHERE (erreur 147), puisque le WHERE est évalué avant le regroupement. Il faut soit trier avec TOP (1), soit calculer le MIN ou le MAX dans une sous-requête.
-- Ne compile pas
SELECT c.Id, c.Name FROM dbo.Customer c
WHERE c.DateOfBirth = MIN(c.DateOfBirth);
-- Réécriture avec une sous-requête scalaire
WITH Eligibles AS (
SELECT c.Id, c.Name, c.DateOfBirth
FROM dbo.Customer c
JOIN dbo.Rentals r ON r.CustomerId = c.Id
GROUP BY c.Id, c.Name, c.DateOfBirth
HAVING COUNT(DISTINCT r.MovieId) >= 3
)
SELECT Id, Name
FROM Eligibles
WHERE DateOfBirth = (SELECT MIN(DateOfBirth) FROM Eligibles);
Autre option : ROW_NUMBER() OVER (ORDER BY DateOfBirth) puis filtrer sur rn = 1. La version sous-requête renvoie naturellement les ex æquo.
Qu'est-ce qu'un index ? Quels sont ses avantages et ses inconvénients ?
Un index est une structure triée (un arbre B+ dans SQL Server) qui permet de retrouver des lignes sans parcourir toute la table, comme l'index d'un film. Il accélère les lectures mais a un coût en écriture et en stockage.
| Type | Principe |
|---|---|
| Clustered | Les données de la table sont physiquement triées selon cette clé. Un seul par table, souvent la clé primaire. |
| Non-clustered | Structure séparée qui contient la clé indexée et un pointeur vers la ligne. Plusieurs possibles par table. |
Couvrant (INCLUDE) | Ajoute des colonnes au niveau feuille pour que la requête soit servie sans retourner lire la table (pas de « key lookup »). |
| Unique | Garantit l'unicité des valeurs, en plus d'accélérer la recherche. |
| Filtré | N'indexe qu'une partie des lignes (WHERE ReturnedAt IS NULL). |
| Avantages | Inconvénients |
|---|---|
Recherche rapide (seek au lieu d'un scan complet) sur WHERE, JOIN, ORDER BY, GROUP BY | Chaque INSERT, UPDATE, DELETE doit aussi mettre à jour tous les index concernés : écritures plus lentes |
Évite des tris coûteux quand l'ordre de l'index correspond au ORDER BY | Espace disque et mémoire supplémentaires |
| Garantit l'unicité (index unique) | Fragmentation avec le temps : maintenance nécessaire (rebuild, reorganize, statistiques) |
| Réduit les verrous et la contention en lisant moins de lignes | Trop d'index ou des index inutilisés : coût sans bénéfice, et l'optimiseur peut mal choisir |
-- Accélère les comptages de locations par film (jointure et regroupement sur MovieId)
CREATE NONCLUSTERED INDEX IX_Rentals_MovieId
ON dbo.Rentals (MovieId);
-- Index couvrant pour les locations d'un client triés par date
CREATE NONCLUSTERED INDEX IX_Rentals_CustomerId_RentedAt
ON dbo.Rentals (CustomerId, RentedAt DESC)
INCLUDE (MovieId);
- Ordre des colonnes dans un index composite : l'index
(CustomerId, RentedAt)sert pour un filtre surCustomerId, pas pour un filtre surRentedAtseul. - Requêtes non SARGable : une fonction sur la colonne empêche l'utilisation de l'index.
WHERE YEAR(RentedAt) = 2024force un scan ;WHERE RentedAt >= '2024-01-01' AND RentedAt < '2025-01-01'permet un seek. - Les clés étrangères ne sont pas indexées automatiquement dans SQL Server.
- Pour vérifier : le plan d'exécution (Index Seek vs Index Scan / Table Scan, Key Lookup).
Sais-tu lire et écrire une procédure stockée ? Comment transformer une requête en procédure ?
Dans beaucoup de SI, une partie de la logique métier est portée par des procédures stockées. Il faut connaître la syntaxe de base, les paramètres, les transactions et la gestion d'erreurs.
CREATE OR ALTER PROCEDURE dbo.usp_GetTopDirectors
@Top INT = 5
AS
BEGIN
SET NOCOUNT ON;
SELECT TOP (@Top) d.Id, d.Name, COUNT(*) AS NbLocations
FROM dbo.Director d
JOIN dbo.Movie m ON m.DirectorId = d.Id
JOIN dbo.Rentals r ON r.MovieId = m.Id
GROUP BY d.Id, d.Name
ORDER BY NbLocations DESC;
END;
GO
-- Procédure d'écriture avec transaction et gestion d'erreur
CREATE OR ALTER PROCEDURE dbo.usp_RentMovie
@CustomerId INT, @MovieId INT
AS
BEGIN
SET NOCOUNT ON;
SET XACT_ABORT ON;
BEGIN TRY
BEGIN TRANSACTION;
IF EXISTS (SELECT 1 FROM dbo.Rentals WITH (UPDLOCK, HOLDLOCK)
WHERE MovieId = @MovieId AND ReturnedAt IS NULL)
THROW 50001, 'Film déjà loué', 1;
INSERT INTO dbo.Rentals (CustomerId, MovieId, RentedAt)
VALUES (@CustomerId, @MovieId, SYSUTCDATETIME());
COMMIT;
END TRY
BEGIN CATCH
IF @@TRANCOUNT > 0 ROLLBACK;
THROW;
END CATCH
END;
SET NOCOUNT ON: supprime les messages « n rows affected », moins de trafic réseau.SET XACT_ABORT ON: toute erreur annule la transaction entière.UPDLOCK, HOLDLOCK: empêche deux locations simultanées du même film (même problème de check-then-act qu'en C#).
Message brokers & architecture asynchrone
Comment plusieurs API communiquent de façon fiable.
À quoi sert un message broker (Kafka, RabbitMQ) ? Dans quels cas l'utiliser ?
Un broker découple un producteur de ses consommateurs : l'appelant publie un message et n'attend pas que le traitement soit fait.
- Traitement asynchrone : envoi d'e-mails, génération de factures PDF, notifications.
- Intégration entre domaines : « commande validée » → stock, facturation, logistique et fidélité réagissent chacun de leur côté.
- Absorber les pics : la file stocke les messages et les consommateurs traitent à leur rythme (soldes, Black Friday).
- Résilience : si un consommateur est arrêté, les messages attendent. Retries et dead-letter queue pour les messages en échec.
| RabbitMQ | Kafka | |
|---|---|---|
| Modèle | File de messages : exchange → routage → queue | Journal distribué : topic découpé en partitions |
| Après lecture | Message supprimé après acquittement | Message conservé (rétention), relecture possible |
| Ordre | Par queue | Garanti par partition (via la clé du message) |
| Points forts | Routage fin, simplicité, faible latence | Très gros débit, event sourcing, rejouer l'historique |
Côté Azure : Service Bus (proche de RabbitMQ) et Event Hubs (proche de Kafka). En .NET : MassTransit, NServiceBus, Wolverine.
Que sont les patterns Inbox et Outbox ? Quel problème résolvent-ils ?
Ils résolvent le problème de la double écriture : on ne peut pas écrire en base et publier sur le broker de façon atomique. Outbox garantit l'envoi côté producteur, Inbox garantit un traitement unique côté consommateur.
Le problème : je sauvegarde la commande puis je publie OrderCreated. Si l'application plante entre les deux, la commande existe mais personne n'est prévenu. Si je publie d'abord et que la sauvegarde échoue, j'ai annoncé une commande qui n'existe pas.
- Outbox (producteur) : dans la même transaction SQL, j'écris la commande et une ligne dans une table
OutboxMessage. Un worker en arrière-plan lit cette table, publie sur le broker, puis marque la ligne comme envoyée. On obtient une livraison « au moins une fois ». - Inbox (consommateur) : comme un message peut arriver deux fois, le consommateur enregistre l'ID du message dans une table
InboxMessage, dans la même transaction que son traitement. Si l'ID existe déjà, il ignore le message. Le traitement devient idempotent.
CREATE TABLE dbo.OutboxMessage (
Id UNIQUEIDENTIFIER PRIMARY KEY,
Type NVARCHAR(200) NOT NULL,
Payload NVARCHAR(MAX) NOT NULL,
OccurredAt DATETIME2 NOT NULL,
ProcessedAt DATETIME2 NULL
);
CREATE TABLE dbo.InboxMessage (
MessageId UNIQUEIDENTIFIER PRIMARY KEY, -- l'unicité bloque le double traitement
ProcessedAt DATETIME2 NOT NULL
);
Design patterns
Mise en situation sur l'API de location de films.
Selon leur catégorie (Comédie, Documentaire…), les films sont stockés dans des sources différentes : SQL Server, une autre base, un fichier Excel. Quel pattern utiliser pour que le reste de l'application ne dépende pas de la source ?
Pattern Strategy, appuyé sur l'abstraction du repository : une interface unique, une implémentation par source, et un composant qui choisit la bonne selon la catégorie. Le service ne connaît que l'interface.
public interface IMovieStore
{
bool CanHandle(string category);
Task<bool> ExistsAsync(string title, string director, CancellationToken ct);
Task<Movie> AddAsync(Movie movie, CancellationToken ct);
}
public sealed class SqlServerMovieStore : IMovieStore
{
public bool CanHandle(string category) => category == "Comédie";
// ... accès SQL Server
}
public sealed class ExcelMovieStore : IMovieStore
{
public bool CanHandle(string category) => category == "Documentaire";
// ... lecture / écriture d'un fichier Excel (ClosedXML)
}
public sealed class MovieStoreResolver(IEnumerable<IMovieStore> stores)
{
public IMovieStore For(string category) =>
stores.FirstOrDefault(s => s.CanHandle(category))
?? throw new NotSupportedException($"Aucune source pour la catégorie {category}");
}
// Le service ne connaît aucune source concrète
public async Task<Movie> AddMovieAsync(Movie movie, CancellationToken ct) =>
await _resolver.For(movie.Category).AddAsync(movie, ct);
// Program.cs
services.AddScoped<IMovieStore, SqlServerMovieStore>();
services.AddScoped<IMovieStore, ExcelMovieStore>();
services.AddScoped<MovieStoreResolver>();
- Inversion de dépendance : le Domain définit l'interface, l'Infrastructure fournit les implémentations. Changer de source ne touche ni au service ni au contrôleur.
- Ajouter une source = ajouter une classe, sans modifier le code existant (principe ouvert/fermé).
- La correspondance catégorie → source peut venir de la configuration (
appsettings.json) plutôt que d'être codée en dur. - Alternative .NET 8 : keyed services,
services.AddKeyedScoped<IMovieStore, SqlServerMovieStore>("Comédie")puisGetRequiredKeyedService<IMovieStore>(category). - Autres patterns à citer si on te pousse : Factory (création de l'implémentation), Adapter (faire ressembler un fichier Excel à un repository), Composite (une façade qui route vers les sources), Decorator (cache ou log autour d'une source).
if/switch sur la catégorie dans le service fonctionne, mais il fait dépendre le service de toutes les sources. On attend un pattern nommé et l'argument d'extensibilité.Live coding : endpoint de location
Tu codes en partage d'écran sur l'API de location de films, avec les données en mémoire. Parle à voix haute : le raisonnement compte autant que le code produit.
Comment implémenter un endpoint qui permet à un client de louer un film ? Que renvoyer, et avec quel code HTTP ?
Un POST, car on crée une ressource « location ». La réponse la plus juste est 201 Created avec la location créée dans le corps et son adresse dans l'en-tête Location.
public sealed record RentMovieRequest(int CustomerId, int MovieId);
public sealed record RentalResponse(int CustomerId, int MovieId, DateTime RentedAt);
[HttpPost("rentals")]
[ProducesResponseType(typeof(RentalResponse), StatusCodes.Status201Created)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
[ProducesResponseType(StatusCodes.Status409Conflict)]
public IActionResult RentMovie([FromBody] RentMovieRequest request)
{
var rental = _rentalService.RentMovie(request.CustomerId, request.MovieId);
var response = new RentalResponse(rental.CustomerId, rental.MovieId, rental.RentedAt);
return CreatedAtAction(nameof(GetCustomerRentals), new { customerId = request.CustomerId }, response);
}
- Route :
POST /api/rentalsavec le corps{ customerId, movieId }, ouPOST /api/customers/{customerId}/rentalsavec{ movieId }. La seconde rend explicite que la location appartient au client. - Service : vérifier que le client existe, que le film existe, qu'il est disponible, puis enregistrer la location et marquer le film comme indisponible.
- Codes HTTP : 201 en cas de succès ; 400 si la requête est mal formée ; 404 si le client ou le film n'existe pas ; 409 si le film est déjà loué.
- Renvoyer un DTO de réponse, jamais l'entité de domaine directement.
- Si les entités sont immuables (propriétés en lecture seule), on ne modifie pas l'objet : on en crée une nouvelle version ou on ajoute une méthode métier explicite (
movie.MarkAsRented()).
200 OK avec la location dans le corps, ou 204 No Content, se défendent aussi. Ce qui compte, c'est de justifier ton choix : 201 dit explicitement qu'une ressource a été créée.Que renvoyer si l'identifiant de client fourni ne correspond à aucun client ? Quel code HTTP et pourquoi ?
404 Not Found, avec un corps ProblemDetails qui précise que le client 42 n'existe pas. Surtout pas une 500 : ce n'est pas une panne du serveur, c'est une donnée fournie par l'appelant qui ne correspond à rien.
// Service
var customer = _customerRepository.GetById(customerId)
?? throw new CustomerNotFoundException(customerId);
// Réponse envoyée par le middleware d'exceptions
HTTP/1.1 404 Not Found
Content-Type: application/problem+json
{
"title": "Client introuvable",
"status": 404,
"detail": "Aucun client avec l'identifiant 42."
}
- Si l'ID est dans l'URL (
/customers/42/rentals) : 404 ne fait pas débat, la ressource demandée n'existe pas. - Si l'ID est dans le corps : 404 reste courant. Certains préfèrent
422 Unprocessable Entity(la requête est bien formée mais ses données ne sont pas exploitables) ou400 Bad Request. Les trois se défendent si tu argumentes et que l'API reste cohérente. - Ne pas confondre avec le film déjà loué : là, client et film existent, c'est l'état du film qui empêche l'opération, donc
409 Conflict.
Une location enchaîne plusieurs opérations : vérifier le client, le film et sa disponibilité, enregistrer la location, mettre à jour le film. Comment garantir que deux requêtes ne louent pas le même film en même temps ?
Toute la séquence « vérifier la disponibilité puis louer » doit être atomique. En mémoire, un seul lock partagé autour de l'ensemble ; avec une base, une transaction et une garantie portée par la base.
Données en mémoire :
private static readonly object RentalLock = new(); // partagé par toutes les requêtes
public Rental RentMovie(int customerId, int movieId)
{
lock (RentalLock)
{
var customer = _customers.GetById(customerId) ?? throw new CustomerNotFoundException(customerId);
var movie = _movies.GetById(movieId) ?? throw new MovieNotFoundException(movieId);
if (!movie.IsAvailable) throw new MovieNotAvailableException(movieId);
var rental = new Rental(customer.Id, movie.Id, DateTime.UtcNow);
_rentals.Add(rental);
_movies.MarkAsRented(movie.Id);
return rental;
}
}
- Le verrou doit couvrir toute la séquence. Verrouiller chaque étape séparément laisse deux requêtes passer le contrôle de disponibilité en même temps.
- Il doit être partagé par toutes les requêtes :
staticou porté par un composant Singleton, pas par un service Scoped. - Toutes les écritures sur les films et les locations doivent passer par ce même verrou.
Avec SQL Server, le lock ne suffit plus dès qu'il y a plusieurs instances. Pistes à évoquer :
- Mise à jour conditionnelle :
UPDATE dbo.Movie SET IsAvailable = 0 WHERE Id = @MovieId AND IsAvailable = 1, puis vérifier le nombre de lignes modifiées. Zéro ligne : quelqu'un a loué le film entre-temps → 409. L'instruction est atomique. - Index unique filtré :
CREATE UNIQUE INDEX UX_ActiveRental ON dbo.Rental (MovieId) WHERE ReturnedAt IS NULL. La base refuse une seconde location en cours sur le même film, quoi qu'il arrive côté application. - Transaction qui regroupe l'insertion de la location et la mise à jour du film, éventuellement avec
UPDLOCK, HOLDLOCKsur la lecture (voir la procédureusp_RentMoviedans la section SQL). - Verrouillage optimiste : une colonne
rowversionsur le film ; EF Core lèveDbUpdateConcurrencyExceptionsi la ligne a changé depuis la lecture.
Aucune question ne correspond. Modifie ta recherche ou ton filtre.