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 vie | Instance | Exemples typiques |
|---|---|---|
| Singleton | Une 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. |
| Scoped | Une par scope. En ASP.NET Core, un scope = une requête HTTP. | DbContext, Unit of Work, contexte utilisateur courant. |
| Transient | Une 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
DbContextpartagé 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 avecIServiceScopeFactory.CreateScope()pour chaque message ou chaque itération. - Un Transient
IDisposablerésolu depuis le conteneur racine n'est libéré qu'à l'arrêt de l'application : fuite mémoire possible.
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 unSELECT … WHERE. - Change tracking : l'ORM suit les entités chargées et génère les
INSERT/UPDATE/DELETEauSaveChanges(). - 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.
FromSql pour appeler une procédure stockée ou une requête de lecture très optimisée.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
DbContextest déjà un Unit of Work (et chaqueDbSetun 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);
}
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.
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.
| Unitaire | Intégration | |
|---|---|---|
| Périmètre | Une classe / une règle, dépendances mockées | Plusieurs couches : API, base, sérialisation, DI |
| Vitesse | Millisecondes, des milliers par build | Plus lents, demandent une infra |
| Détecte | Erreurs de logique, cas limites | Mapping EF, SQL, config, routing, contrats |
| Limite | Ne prouve pas que l'ensemble marche | Diagnostic plus difficile, maintenance plus lourde |
- Outils : xUnit / NUnit, Moq / NSubstitute, FluentAssertions ;
WebApplicationFactoryet 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.
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.
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.
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) ettracestate. - En .NET, la trace courante est
Activity.Current(System.Diagnostics), et OpenTelemetry fournitPropagators.DefaultTextMapPropagatorpour 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);
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.
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.
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.
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.
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).
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.
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.
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).
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.WriteLineoublié, 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.
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.
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.
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.
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.
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.
Aucune question ne correspond. Modifie ta recherche ou ton filtre.