Carbon IT · Préparation candidat

Entraîne-toi à l'entretien technique .NET

Les questions ci-dessous couvrent les thèmes classiques d'un entretien technique .NET. Lis la question, formule ta réponse à voix haute, puis déplie pour comparer. Marque chaque question « Je maîtrise » ou « À revoir » pour suivre ta progression.

0 maîtrisée · 0 à revoir

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 ?
ConseilPrépare pour chacune un exemple concret tiré de tes missions, avec des ordres de grandeur précis (années, volumétrie, req/s, taille d'équipe). Attends-toi à des relances dès qu'une réponse reste vague.

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() ou UseSerilogRequestLogging().
  • 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 Scrutor services.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);
    }
}
PiègeUtilise des messages structurés ("{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);
PiègeAjouter le paramètre ne suffit pas. Si la méthode est synchrone ou travaille en mémoire (comme le repository de l'exercice), il ne sert à rien : il faut rendre la chaîne asynchrone jusqu'à l'I/O pour qu'il ait un effet. C'est la nuance attendue.
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;
    }
}
PiègeDes exceptions pour le contrôle de flux métier, c'est discutable. Sois prêt à évoquer l'alternative du pattern Result (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.

  1. List<T> n'est pas thread-safe : deux Add simultanés peuvent corrompre la liste ou perdre un élément.
  2. 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.
  3. Génération d'ID du type Max(m => m.Id) + 1 : deux requêtes calculent le même ID.
  4. GetAll() renvoie AsReadOnly(), une simple vue sur la liste vivante. Énumérer pendant un ajout lève InvalidOperationException: Collection was modified.
Méthode pour répondreCommence par la durée de vie DI (Singleton = état partagé), puis cite la race condition précise. C'est ce raisonnement qui est évalué.
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 lock garantit 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 lock et 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 sur this ni 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'await dans un lock.

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 _sync déclaré dans un service enregistré en Scoped ou Transient est 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 être static.
  • Une partie de l'accès reste hors du verrou : si GetAll lit la liste sans lock pendant 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.
PiègeUn 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.

Comment utiliser cette listePersonne n'attend que tu cites tous ces points. Ce sont des pistes à évoquer : choisis-en quelques-unes, en commençant par la persistance et l'unicité, et appuie-les autant que possible sur ton expérience (« sur mon projet précédent, on avait… »). Une piste illustrée par un cas réel vaut mieux qu'une liste récitée.
  1. Persistance : SQL Server via EF Core ou Dapper, repository en Scoped (un DbContext par requête).
  2. ID générés par la base (IDENTITY ou SEQUENCE), plus de Max + 1.
  3. 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.
  4. Concurrence : verrouillage optimiste avec rowversion sur les mises à jour (ex. location d'un film disponible).
  5. Async de bout en bout + CancellationToken.
  6. Cache : pas de cache mémoire local incohérent entre instances. Utiliser un cache distribué (Redis) avec invalidation, ou accepter une expiration courte.
  7. Idempotence des POST (clé d'idempotence) pour gérer les retries du load balancer ou du client.
  8. Exploitabilité : health checks (/health) pour les probes Kubernetes, configuration externalisée, Correlation ID, logs centralisés.
  9. Verrou distribué (sp_getapplock, Redis) seulement si un traitement doit vraiment être exclusif entre instances.
Détail à repérerRegarde la durée de vie de chaque repository dans l'injection de dépendances. Un repository en mémoire enregistré en 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 EXISTS qui 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 le EXISTS instantané.
  • Éviter de faire fuiter IQueryable hors 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.

  1. 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.
  2. Doublon, requête ciblée : un EXISTS sur titre et réalisateur, appuyé sur un index. Il permet de renvoyer un message clair (409).
  3. Contrainte d'unicité en base : index unique (DirectorId, Title). Entre le EXISTS et 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 EXISTS et 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 en Scoped à 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'un GetAll gé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.SaveChangesAsync en 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).
Débat classique« EF Core est déjà un repository et une Unit of Work, faut-il en rajouter un ? » Avoir un avis argumenté (testabilité, isolation du Domain, requêtes spécifiques) est apprécié.

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.
  • IsAvailable peut être déduit (aucune location avec ReturnedAt 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.

  • CustomerId et MovieId en 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.
PiègeCôté code, les locations sont souvent modélisées comme une collection dans 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érer NEWSEQUENTIALID() 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.

SolutionPrincipeCompromis
GUID / UUIDGénéré côté application (Guid.NewGuid()), unique sans coordination16 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équenceObjet SEQUENCE de la base, interrogé avant l'insert (NEXT VALUE FOR)Un aller-retour par ID, sauf à réserver des plages
HiLoL'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 compteursUne ligne par entité, incrémentée de façon atomique : UPDATE … SET @id = Value = Value + 1Simple, mais point de contention si beaucoup d'insertions
Compteur externeINCR Redis, atomiqueUne dépendance de plus à exploiter
SnowflakeID 64 bits composé de l'horodatage, d'un identifiant de machine et d'un compteur localTrié dans le temps, sans coordination ; dépend de l'horloge des machines
PiègeSELECT 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 du SELECT est utilisable dans l'ORDER BY, car celui-ci est évalué après.
  • Toute colonne du SELECT qui n'est pas agrégée doit figurer dans le GROUP BY : ici d.Id et d.Name. Regrouper aussi par film donnerait un total par film, pas par réalisateur.
  • Ex æquo au 5ᵉ rang : SELECT TOP (5) WITH TIES les inclut.
  • Pour inclure les réalisateurs sans aucune location : LEFT JOIN sur les deux tables et COUNT(r.MovieId), qui ne compte pas les NULL.
Erreurs fréquentesOublier le 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 BY de la requête la plus externe garantit l'ordre du résultat.
  • Avec TOP, l'ORDER BY est 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;
Piège n°1Plus âgé = date de naissance la plus ancienne = 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.
Piège n°2« 3 films différents » n'est pas « 3 locations » : un client qui a loué trois fois le même film ne doit pas sortir. 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 :

ÉtapeClauseRôle
1FROM / JOINConstruire l'ensemble de lignes
2WHEREFiltrer les lignes (pas d'agrégat possible)
3GROUP BYFormer les groupes
4HAVINGFiltrer les groupes (agrégats autorisés)
5SELECTCalculer les colonnes et les alias
6ORDER BYTrier (les alias du SELECT sont visibles)
7TOP / OFFSETLimiter 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.

TypePrincipe
ClusteredLes données de la table sont physiquement triées selon cette clé. Un seul par table, souvent la clé primaire.
Non-clusteredStructure 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 »).
UniqueGarantit l'unicité des valeurs, en plus d'accélérer la recherche.
FiltréN'indexe qu'une partie des lignes (WHERE ReturnedAt IS NULL).
AvantagesInconvénients
Recherche rapide (seek au lieu d'un scan complet) sur WHERE, JOIN, ORDER BY, GROUP BYChaque 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 BYEspace 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 lignesTrop 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 sur CustomerId, pas pour un filtre sur RentedAt seul.
  • Requêtes non SARGable : une fonction sur la colonne empêche l'utilisation de l'index. WHERE YEAR(RentedAt) = 2024 force 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).
À retenirUne table très lue et peu écrite supporte bien plusieurs index. Une table qui reçoit beaucoup d'écritures (logs, historiques) doit en avoir peu et bien choisis.
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.
RabbitMQKafka
ModèleFile de messages : exchange → routage → queueJournal distribué : topic découpé en partitions
Après lectureMessage supprimé après acquittementMessage conservé (rétention), relecture possible
OrdrePar queueGaranti par partition (via la clé du message)
Points fortsRoutage fin, simplicité, faible latenceTrè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
);
À retenirOutbox + Inbox = effet « exactement une fois » en pratique, alors que le transport ne garantit que « au moins une fois ». MassTransit et NServiceBus les proposent clé en main.

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") puis GetRequiredKeyedService<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).
PiègeUn 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/rentals avec le corps { customerId, movieId }, ou POST /api/customers/{customerId}/rentals avec { 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()).
Réponses acceptables200 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) ou 400 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 : static ou 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, HOLDLOCK sur la lecture (voir la procédure usp_RentMovie dans la section SQL).
  • Verrouillage optimiste : une colonne rowversion sur le film ; EF Core lève DbUpdateConcurrencyException si la ligne a changé depuis la lecture.
Comment répondreCommence par la version en mémoire (c'est le contexte du live coding), puis montre que tu sais qu'elle ne tient pas à plusieurs instances et cite une ou deux pistes côté base.