Carbon IT · Préparation candidat

Questions ouvertes .NET

Questions complémentaires relevées en entretien technique .NET : fondamentaux .NET, qualité, observabilité, un cas pratique sur le fonctionnement agile de l'équipe et des questions de soft skills. Même principe : formule ta réponse à voix haute, puis déplie pour comparer.

0 maîtrisée · 0 à revoir

Fondamentaux .NET

Injection de dépendances et accès aux données.

Explique les durées de vie de l'injection de dépendances : Singleton, Transient, Scoped.

La durée de vie dit au conteneur combien de temps il garde une instance et avec qui il la partage.

Durée de vieInstanceExemples typiques
SingletonUne seule pour toute l'application, partagée entre toutes les requêtes et tous les threads.Cache mémoire, configuration, HttpClient via IHttpClientFactory, client de bus.
ScopedUne par scope. En ASP.NET Core, un scope = une requête HTTP.DbContext, Unit of Work, contexte utilisateur courant.
TransientUne nouvelle à chaque résolution.Services légers et sans état, validateurs, mappers.
builder.Services.AddSingleton<IClock, SystemClock>();
builder.Services.AddScoped<IMovieRepository, SqlMovieRepository>();
builder.Services.AddTransient<IRentalValidator, RentalValidator>();
  • Captive dependency : un Singleton qui dépend d'un Scoped garde ce Scoped vivant pour toujours. Exemple classique : un DbContext partagé entre requêtes, donc non thread-safe et avec un cache qui grossit. En Development, ASP.NET Core lève une exception (ValidateScopes).
  • Un Singleton doit être thread-safe, puisqu'il est appelé en parallèle par toutes les requêtes.
  • Hors requête HTTP (BackgroundService, consumer de messages), il n'y a pas de scope automatique : on en crée un avec IServiceScopeFactory.CreateScope() pour chaque message ou chaque itération.
  • Un Transient IDisposable résolu depuis le conteneur racine n'est libéré qu'à l'arrêt de l'application : fuite mémoire possible.
PiègeRéciter les trois définitions ne suffit pas. On attend la règle de compatibilité (un service ne doit dépendre que de durées de vie égales ou plus longues) et un exemple concret de bug causé par une mauvaise durée de vie.
As-tu déjà utilisé un ORM ? À quoi ça sert ? Explique-moi le concept.

Un ORM (Object-Relational Mapper) fait le pont entre le modèle objet de l'application et le modèle relationnel de la base : il traduit des objets C# en lignes de tables, et des requêtes LINQ en SQL.

  • Mapping : une classe ↔ une table, une propriété ↔ une colonne, les navigations ↔ les clés étrangères.
  • Traduction de requêtes : context.Movies.Where(m => m.Genre == "Comédie") devient un SELECT … WHERE.
  • Change tracking : l'ORM suit les entités chargées et génère les INSERT / UPDATE / DELETE au SaveChanges().
  • Migrations : faire évoluer le schéma depuis le code.

Exemples en .NET : Entity Framework Core (ORM complet), Dapper (micro-ORM : tu écris le SQL, il mappe le résultat), NHibernate.

ConseilBeaucoup de SI s'appuient encore sur des procédures stockées : montre que tu sais utiliser les deux mondes. EF Core pour le CRUD et le métier, Dapper ou FromSql pour appeler une procédure stockée ou une requête de lecture très optimisée.
PiègeConnais les défauts : problème N+1 (lazy loading dans une boucle), requêtes générées peu efficaces, tracking inutile en lecture (utilise AsNoTracking()), chargement de colonnes inutiles (projette avec Select).
Le pattern « Unit of Work », ça te parle ?

Le Unit of Work regroupe toutes les modifications d'une opération métier et les valide en une seule transaction : tout est enregistré, ou rien.

  • Les repositories enregistrent les changements, le Unit of Work les commit ensemble via un SaveChangesAsync() / CommitAsync() unique.
  • Exemple : louer un film = créer la location + décrémenter le nombre de copies disponibles + mettre à jour l'historique du client. Si une étape échoue, rien n'est persisté.
  • Dans EF Core, le DbContext est déjà un Unit of Work (et chaque DbSet un repository). SaveChanges() ouvre une transaction et applique tout.
  • Le Unit of Work est en général Scoped : une instance par requête, partagée par tous les repositories de cette requête.
public interface IUnitOfWork
{
    IMovieRepository Movies { get; }
    IRentalRepository Rentals { get; }
    Task<int> SaveChangesAsync(CancellationToken ct = default);
}
Pour aller plus loinLe pattern Outbox s'appuie sur le Unit of Work : le message à publier est écrit dans une table de la même base, dans la même transaction que les données métier.

Qualité, tests et architecture

Comment tu garantis que ce que tu livres est fiable, performant et maintenable.

Comment sais-tu que ce que tu livres est performant ? Y a-t-il des outils qui permettent d'optimiser la performance ?

On ne devine pas la performance, on la mesure : avant la livraison avec des tests ciblés, puis en production avec du monitoring.

  • Micro-benchmarks : BenchmarkDotNet pour comparer deux implémentations (temps et allocations).
  • Tests de charge : k6, JMeter, NBomber, Azure Load Testing. On regarde latence p95 / p99, débit, taux d'erreur.
  • Profiling : dotTrace, dotMemory, Visual Studio Profiler, dotnet-counters, dotnet-trace.
  • Base de données : plan d'exécution SQL Server, Query Store, index manquants, logs SQL d'EF Core pour repérer les N+1.
  • Production : APM (Datadog, Application Insights), traces distribuées, métriques, alertes sur la latence.
ConseilDonne un exemple vécu : « endpoint à 2 s, trace Datadog → 40 requêtes SQL (N+1), ajout d'un Include et d'un index → 150 ms ». Une mesure avant / après vaut plus qu'une liste d'outils.
Les tests : unitaires ou d'intégration ? Quelle pertinence pour chacun ?

Les deux sont complémentaires : les tests unitaires vérifient la logique métier rapidement et en isolation, les tests d'intégration vérifient que les briques fonctionnent vraiment ensemble.

UnitaireIntégration
PérimètreUne classe / une règle, dépendances mockéesPlusieurs couches : API, base, sérialisation, DI
VitesseMillisecondes, des milliers par buildPlus lents, demandent une infra
DétecteErreurs de logique, cas limitesMapping EF, SQL, config, routing, contrats
LimiteNe prouve pas que l'ensemble marcheDiagnostic plus difficile, maintenance plus lourde
  • Outils : xUnit / NUnit, Moq / NSubstitute, FluentAssertions ; WebApplicationFactory et Testcontainers (SQL Server dans Docker) pour l'intégration.
  • La pyramide classique met beaucoup d'unitaires à la base. Pour une API surtout CRUD, le « trophée » de tests met plutôt l'accent sur l'intégration, qui couvre plus de risque réel.
PiègeMocker le DbContext ou utiliser le provider InMemory donne une fausse confiance : il ne se comporte pas comme SQL Server (transactions, contraintes, traduction LINQ). Pour tester l'accès aux données, préfère une vraie base.
As-tu utilisé SonarQube ? À quoi ça sert ?

SonarQube fait de l'analyse statique de code : il inspecte le code sans l'exécuter pour mesurer sa qualité et détecter des problèmes avant la mise en production.

  • Bugs : null reference potentielle, ressource non disposée…
  • Vulnérabilités et security hotspots : injection SQL, secret en dur, crypto faible.
  • Code smells et dette technique : complexité cyclomatique, méthodes trop longues, code mort.
  • Duplication et couverture de tests (à partir des rapports Coverlet / OpenCover).
  • Quality Gate : seuils bloquants dans la CI, par exemple « couverture du nouveau code ≥ 80 %, zéro bug bloquant ». Le principe Clean as You Code se concentre sur le nouveau code.

Il s'intègre à la CI (Azure DevOps, GitHub Actions) et décore les pull requests. SonarLint fait la même chose dans l'IDE. SonarCloud est la version SaaS.

PiègeLe nom est SonarQube. Et une couverture élevée ne prouve pas que les tests sont bons : c'est un indicateur, pas un objectif.
La Clean Architecture, comment la définis-tu ? Qu'est-ce que ça apporte concrètement ?

La Clean Architecture organise le code en couches concentriques avec une règle unique : les dépendances pointent vers le centre. Le métier ne dépend de rien, l'infrastructure dépend du métier.

  • Domain : entités, règles métier, value objects. Aucune dépendance technique.
  • Application : cas d'usage, interfaces (IMovieRepository), DTO.
  • Infrastructure : implémentations techniques (EF Core, bus, API externes).
  • Présentation : contrôleurs API, branchement de la DI.

Ce que ça apporte concrètement :

  • Métier testable en unitaire sans base ni HTTP.
  • Changer de technologie (SQL Server → autre base, REST → bus) sans toucher au métier, grâce à l'inversion de dépendance.
  • Code lisible : on sait où chercher et où ajouter une fonctionnalité.
  • Utile pour migrer un legacy progressivement.
PiègeMontre du recul : sur un petit service CRUD, c'est souvent trop de cérémonie (beaucoup de projets, de mapping, d'interfaces à une seule implémentation). Cite les alternatives comme le Vertical Slice. Un avis argumenté vaut mieux qu'une adhésion dogmatique.

Observabilité et traces distribuées

Suivre une requête de bout en bout quand elle traverse plusieurs services.

Comment propager le contexte de trace à travers un bus de messages ?

En HTTP, le contexte de trace voyage dans les headers. Sur un bus, on fait pareil : le producteur injecte le contexte dans les métadonnées du message, le consommateur l'extrait et démarre son activité comme enfant de celle du producteur.

  • Standard W3C Trace Context : header traceparent (trace id + span id + flags) et tracestate.
  • En .NET, la trace courante est Activity.Current (System.Diagnostics), et OpenTelemetry fournit Propagators.DefaultTextMapPropagator pour injecter / extraire.
  • On place le contexte dans les propriétés applicatives du message (Azure Service Bus ApplicationProperties, headers RabbitMQ ou Kafka), pas dans le payload métier.
  • Beaucoup de librairies le font déjà : Azure SDK, MassTransit, NServiceBus, et l'instrumentation automatique Datadog.
// Producteur
Propagators.DefaultTextMapPropagator.Inject(
    new PropagationContext(Activity.Current!.Context, Baggage.Current),
    message.ApplicationProperties,
    (props, key, value) => props[key] = value);

// Consommateur
var parent = Propagators.DefaultTextMapPropagator.Extract(default,
    msg.ApplicationProperties,
    (props, key) => props.TryGetValue(key, out var v) ? [v.ToString()!] : []);
using var activity = Source.StartActivity("process movie-rented",
    ActivityKind.Consumer, parent.ActivityContext);
PiègeAvec l'Outbox, le message est publié plus tard par un autre processus : il faut stocker le traceparent dans la table outbox au moment de l'écriture, sinon la trace est coupée. Cite aussi le correlation id métier, utile même sans outil de tracing.

Cas pratique Agile

Questions de posture : comment tu t'impliques dans l'équipe et dans la vie de ton code, au-delà du développement.

Quelle est ta posture vis-à-vis de l'animation de l'équipe ?

L'animation n'est pas réservée à un rôle : chaque membre contribue à ce que l'équipe fonctionne bien. Le recruteur cherche un développeur actif, pas un exécutant.

  • Participer réellement aux rituels : préparer le daily, proposer des sujets en rétro, challenger les estimations en refinement.
  • Partager : revues de code bienveillantes, pair programming, présentation d'un sujet technique à l'équipe.
  • Remonter tôt les blocages et proposer des améliorations de process.
  • Pouvoir prendre l'animation d'un rituel quand c'est utile, sans prendre la place des autres.
ConseilAppuie-toi sur un exemple : une rétro que tu as animée, une pratique que tu as introduite (template de PR, revue de code en binôme…), et ce que ça a changé.
Quel est le rôle du développeur dans le suivi de son code, jusqu'en pré-production et même en production ?

Le travail ne s'arrête pas au merge. Le développeur est responsable de sa fonctionnalité jusqu'à ce qu'elle apporte de la valeur en production : « you build it, you run it ».

  • Avant : définition of done claire, tests, instrumentation (logs structurés, métriques, traces) prévue dès le développement.
  • En recette / pré-prod : déployer, vérifier soi-même, accompagner le PO ou la QA, corriger vite.
  • Mise en production : être présent, surveiller les dashboards et les erreurs, connaître le plan de rollback, utiliser des feature flags si possible.
  • Après : suivre les indicateurs, traiter les incidents, participer au post-mortem.
TendanceAvec Kubernetes et l'approche DevOps, les équipes deviennent propriétaires de leurs configurations et de leurs déploiements : cette posture d'ownership est de plus en plus attendue.
S'il n'y a pas de Scrum Master dans l'équipe, qui peut assurer le rôle d'animateur ?

N'importe quel membre de l'équipe, y compris un développeur. L'important est que le rôle de facilitation soit tenu, pas qui le tient.

  • Options : le Tech Lead, un développeur volontaire, ou une rotation entre les membres (sprint par sprint ou rituel par rituel).
  • La rotation responsabilise tout le monde et évite qu'une seule personne porte la charge.
  • Point d'attention : éviter que le PO anime seul. Il est partie prenante dans les arbitrages, ce qui peut biaiser les échanges (rétro notamment).
  • L'animateur garantit le cadre (timebox, parole partagée, actions de rétro suivies), il ne décide pas à la place de l'équipe.
ConseilDis que tu es prêt à le prendre. C'est souvent ce que la question cherche à vérifier.
Il y a un problème sur la fonctionnalité que tu développes : qui est responsable ?

L'équipe est collectivement responsable, et moi en premier en tant que développeur de la fonctionnalité. Je ne cherche pas un coupable, je prends le sujet en main.

  • Agir : qualifier le problème, prévenir l'équipe et le PO, corriger ou rollback selon l'impact.
  • Collectif : le code a été relu, testé, validé par plusieurs personnes. Un bug en production révèle un trou dans le process, pas seulement une erreur individuelle.
  • Apprendre : post-mortem sans blâme (« blameless »), puis action concrète : test manquant, alerte, critère d'acceptation à préciser.
PiègeDeux mauvaises réponses : rejeter la faute (« le PO avait mal spécifié », « la QA aurait dû voir ») ou tout porter seul sans prévenir. Ce qui est attendu : ownership et transparence.

Soft skills

Ta façon de travailler, ton recul et ce que tu apportes à une équipe. Pas de bonne réponse unique : on écoute ton raisonnement et tes exemples.

Que peux-tu me dire sur la Clean Architecture ?

Question très ouverte : on teste autant ta capacité à structurer une explication que ta connaissance du sujet. Va du principe au concret, puis donne ton avis.

  • Le principe en une phrase : les dépendances pointent vers le métier, l'infrastructure est un détail branché à l'extérieur.
  • Les couches : Domain, Application, Infrastructure, Présentation (le détail est dans la section « Qualité, tests et architecture »).
  • Ton vécu : un projet où tu l'as appliquée, ce que ça a facilité (tests, changement de techno) et ce qui a coûté (mapping, nombre de projets).
  • Ton avis : quand tu la choisirais, quand tu préférerais plus simple (Vertical Slice, simple découpage en couches).
ConseilStructure ta réponse en 3 temps : définition, exemple vécu, limites. Deux minutes suffisent, laisse l'interlocuteur creuser.
Quand utilises-tu l'IA pour le développement, et quand t'en passes-tu ?

On attend un usage assumé et maîtrisé : l'IA accélère, mais tu restes responsable de chaque ligne livrée.

  • Quand je l'utilise : code répétitif (mapping, DTO, tests de cas limites), exploration d'une API ou d'une librairie, explication d'un code legacy, premier jet de requête SQL ou de regex, revue rapide avant PR.
  • Quand je m'en passe : décisions d'architecture et de modélisation métier, code sensible (sécurité, calculs financiers) sans relecture attentive, apprentissage d'une notion de fond que je veux vraiment comprendre.
  • Mes garde-fous : je relis et je comprends tout ce que je garde, je teste, je ne colle jamais de données client ou de secrets dans un outil non validé par l'entreprise.
PiègeDeux extrêmes à éviter : « je ne l'utilise jamais » (manque de curiosité) et « je génère tout » (perte de maîtrise). Cite les outils réels que tu utilises (Copilot, Claude, Cursor…) et un exemple où l'IA s'est trompée et où tu l'as détecté.
Que peux-tu nous apporter ?

Relie tes forces au besoin du client ou de l'équipe. Une réponse générique (« je suis motivé et rigoureux ») ne marque pas.

  • Prépare-toi : relis l'offre ou le contexte de mission (stack, enjeux, taille d'équipe) et choisis 2 ou 3 atouts qui y répondent.
  • Technique : une compétence précise utile ici (ex. : migration .NET Framework → .NET 8, mise en place de tests, observabilité).
  • Humain : ce que tu apportes à l'équipe (partage, documentation, regard neuf, énergie, facilité à poser des questions).
  • Une preuve pour chaque atout : un fait tiré de tes missions.
ConseilFormat court : « Je peux vous apporter X, parce que sur ma mission Y j'ai fait Z. » Termine en montrant que tu as aussi envie d'apprendre d'eux.
Quelle est la dernière fois que tu as été force de proposition sur un choix technique ?

Question comportementale : on veut une histoire réelle, datée, avec un résultat. Prépare-la à l'avance avec la méthode STAR.

  • Situation : le contexte (projet, équipe, contrainte).
  • Tâche : le problème que tu as identifié.
  • Action : ce que tu as proposé, comment tu l'as argumenté (POC, comparatif, chiffres) et comment tu as embarqué l'équipe.
  • Résultat : ce que ça a changé, mesurable si possible (temps de build, nombre de bugs, temps de réponse).
ConseilUne proposition refusée est aussi un bon exemple, si tu expliques ce que tu as appris et comment tu as accepté la décision collective. Ça montre que tu proposes sans imposer.
Qu'est-ce qu'une bonne PR ?

Une bonne PR est facile à relire et sûre à fusionner. Elle respecte le temps du relecteur.

  • Petite et ciblée : un seul sujet, pas de refacto opportuniste mélangée à une fonctionnalité.
  • Description claire : le pourquoi, le lien vers le ticket, ce qui a changé, comment tester, captures si UI.
  • Prête : CI verte, tests ajoutés, pas de code mort ni de Console.WriteLine oublié, auto-relecture faite avant de demander une revue.
  • Commits lisibles : messages explicites, historique propre.
  • Côté revue : commentaires bienveillants et argumentés, distinguer le bloquant de la suggestion, répondre à chaque remarque.
ConseilParle aussi de ta posture de relecteur : une PR, c'est un échange d'équipe, pas un examen.
Qu'est-ce qu'un code propre ?

Un code propre se lit facilement et se modifie sans peur. Il est écrit pour le prochain développeur, qui sera peut-être toi dans six mois.

  • Lisible : nommage explicite, méthodes courtes qui font une seule chose, peu d'imbrications.
  • Simple : KISS, YAGNI, pas d'abstraction prématurée. DRY sans excès.
  • Testé : les tests sécurisent le changement et documentent le comportement.
  • Cohérent : conventions de l'équipe respectées, formatage automatique (.editorconfig, analyseurs).
  • Principes : SOLID comme repères, pas comme dogme.
PiègeRéciter SOLID ne suffit pas. Donne un exemple concret : une méthode de 200 lignes que tu as découpée, un nommage qui t'a fait perdre du temps.
Aimes-tu charger ton code de commentaires ?

Non : le code doit se suffire pour dire quoi et comment. Le commentaire sert à expliquer le pourquoi quand le code ne peut pas le dire.

  • À éviter : commentaires qui paraphrasent le code (// incrémente i), code commenté laissé en place (git s'en souvient), commentaires obsolètes qui mentent.
  • Utiles : règle métier non évidente, contournement d'un bug externe, choix de performance contre-intuitif, lien vers un ticket ou une doc.
  • Documentation d'API : les commentaires XML (///) sur une API publique ou une librairie partagée ont leur place (Swagger, IntelliSense).
  • Si un bloc a besoin d'un commentaire pour être compris, se demander d'abord s'il ne faut pas l'extraire dans une méthode bien nommée.
ConseilFormule simple à retenir : « le code dit comment, le commentaire dit pourquoi ».
Doit-on toujours dire oui au métier ?

Non, mais on ne dit pas non sèchement non plus. On comprend le besoin réel derrière la demande, puis on propose la meilleure solution en exposant les compromis.

  • Comprendre : demander le pourquoi. La demande exprimée est souvent une solution, le besoin est derrière.
  • Éclairer : chiffrer le coût, les risques (sécurité, dette, performance, délai), proposer des alternatives ou un découpage (MVP).
  • Laisser arbitrer : la priorisation revient au PO / métier, mais avec toutes les cartes en main.
  • Limites non négociables : sécurité, légalité (RGPD), intégrité des données. Là, on alerte clairement et on escalade si besoin.
Piège« Oui à tout » montre un exécutant, « non » un développeur rigide. La bonne posture : « oui, et voici ce que ça implique » ou « non, mais voici ce que je propose ». Un exemple vécu de négociation rend la réponse crédible.
Qu'est-ce qu'un développeur pro-actif ?

C'est un développeur qui n'attend pas qu'on lui dise quoi faire pour améliorer les choses, tout en restant aligné avec l'équipe.

  • Il anticipe : signale un risque ou une ambiguïté dans un ticket avant de coder, prévient tôt quand il est bloqué ou en retard.
  • Il améliore : laisse le code un peu plus propre qu'il ne l'a trouvé (règle du boy scout), propose des outils ou des process.
  • Il s'implique : surveille ses fonctionnalités en production, aide les collègues, documente.
  • Il apprend : veille technique, partage ses découvertes.
PiègePro-actif ne veut pas dire agir seul dans son coin : refondre un module sans en parler à l'équipe, c'est de l'initiative mal placée. Propose, puis agis avec l'accord de l'équipe.
Pourquoi prendre un jeune développeur comme toi plutôt qu'un confirmé ?

Ne te dévalorise pas et ne prétends pas être un senior. Assume ton profil et transforme-le en atout.

  • Capacité d'apprentissage : montre à quelle vitesse tu as monté en compétence (une techno apprise sur une mission, une formation suivie seul).
  • Regard neuf : pratiques récentes (.NET moderne, IA, CI/CD), pas d'habitudes figées, tu poses les questions qui font avancer.
  • Investissement long terme : un profil qu'on forme aux pratiques de l'équipe, motivé et qui grandit avec le projet.
  • Lucidité : tu connais tes axes de progression et tu sais demander de l'aide au bon moment, ce qui limite les risques.
ConseilTermine par un fait : « sur ma dernière mission, j'ai pris en main X en deux semaines et livré Y ». Un exemple concret vaut plus que des qualités affirmées.