.NET 10 (LTS) · .NET 11 (aperçu) · C# 14 & 15 · EF Core · Minimal API · Blazor
Comprendre .NET, vraiment.
Une documentation qui commence par expliquer ce qu'est une interface avant de te parler de covariance générique. Chaque notion arrive avec une image mentale, un schéma, un exemple, et le mot technique cliquable quand il faut bien finir par l'employer.
- 22 chapitres
- 3 niveaux de lecture
- 200 termes expliqués
- 0 prérequis
Comment cette documentation fonctionne
🎚️ Trois niveaux d'affichage
En haut à droite : Débutant, Intermédiaire, Expert. Le texte de base ne change pas ; ce sont les encadrés avancés, les détails d'implémentation et les subtilités de performance qui apparaissent quand tu montes le curseur. Tu peux relire le même chapitre plus tard, un cran plus haut.
❓ Chaque terme technique est cliquable
Un mot souligné en pointillés comme interface, scoped ou problème N+1 ouvre une fiche : définition sans jargon, image concrète, mini-exemple, termes voisins. Essaie, clique.
🖼️ Des images plutôt que des définitions
Le tas de mémoire est un entrepôt, une interface est une prise électrique, async/await est un
serveur de restaurant. Les schémas sont dessinés (SVG), pas photographiés : ils suivent le thème clair/sombre
et restent lisibles à l'impression.
🔍 Recherche instantanée
Ctrl+K (ou la touche /) ouvre la recherche : chapitres, sections et glossaire. Elle ignore les accents. Et chaque chapitre a un bouton « marquer comme lu » pour suivre ta progression dans la barre de gauche.
Personne ne retient tout. Les bons développeurs ne mémorisent pas : ils savent où retrouver et surtout pourquoi c'était comme ça. Cette doc est écrite pour la relecture rapide : chaque chapitre finit par un bloc « À retenir » en 5 lignes, et le fichier Mémos & pièges rassemble tout en tableaux.
Quel parcours pour toi ?
Suis simplement l'ordre des chapitres, niveau Débutant, sans chercher à tout comprendre du premier coup. Objectif : arriver au chapitre 5 en ayant compris ce qu'est un objet.
- C'est quoi .NET ? — le décor
- Le vocabulaire de base — les 20 mots qui reviennent partout
- Types et mémoire — pourquoi ta modification « ne se voit pas »
- La programmation objet
- Interface et abstraction — le déclic
Ensuite seulement : LINQ (7), async (8), puis une vraie application avec Minimal API et EF Core.
Tu connais les boucles et les fonctions : ne perds pas de temps sur 1–2, mais ne saute pas 3 et 6, qui concentrent les différences de C# avec les autres langages.
- Types valeur vs référence — le piège nº 1 des gens venus de Python/JS
- Modificateurs d'accès —
internaln'existe pas ailleurs - Null et robustesse — le compilateur t'engueule, et il a raison
- C# moderne — records, pattern matching, ce qui rend le code court
- Injection de dépendances — l'ADN de tout projet ASP.NET Core
Deux chapitres récapitulatifs, écrits pour être lus d'affilée, avec l'impact réel sur du code existant :
- Tout .NET 10 (LTS) — C# 14, extension members, validation des Minimal API, EF 10, Blazor 10
- Tout .NET 11 (aperçu) — C# 15 (unions,
closed), runtime async, EF 11, sortie prévue le 10 novembre 2026
Passe le niveau sur Expert avant de les lire : la moitié du contenu y est cachée.
Les questions qui tombent, et le chapitre qui y répond en profondeur :
| Question classique | Où |
|---|---|
| Interface ou classe abstraite ? | Ch. 5 |
struct vs class, pile vs tas | Ch. 3 |
Différence internal / protected | Ch. 6 |
IEnumerable vs IQueryable | Ch. 7 |
Pourquoi .Result provoque un interblocage | Ch. 8 |
| Singleton / scoped / transient | Ch. 11 |
| Le problème N+1 et comment le voir | Ch. 15 |
| Quel mode de rendu Blazor choisir | Ch. 16 |
Le sommaire complet
C'est quoi .NET ?
Runtime, SDK, compilation, ramasse-miettes, versions LTS. Le décor avant les acteurs.
Le vocabulaire de base
Variable, type, méthode, classe, projet, assembly : les mots qu'on n'ose plus demander.
Types, mémoire, valeur vs référence
Pile, tas, copies, null. La source de la moitié des bugs mystérieux.
La programmation objet
Encapsulation, héritage, polymorphisme — expliqués sans le vocabulaire de 1995.
Interface, abstraction, contrat
Le chapitre qui rend le reste évident. Interface ou classe abstraite : la vraie réponse.
public, private, internal…
Les 6 niveaux de visibilité, avec un simulateur pour voir qui voit quoi.
Collections, génériques et LINQ
Listes, dictionnaires, <T>, et l'art d'interroger des données en une ligne.
async / await sans douleur
Pourquoi ça existe, ce que fait vraiment await, et les 4 façons de tout casser.
Erreurs, null et robustesse
Exceptions, using, types nullables, validation : rendre le code difficile à casser.
C# moderne (12 → 15)
Records, pattern matching, expressions de collection, unions. Écrire 3 lignes au lieu de 30.
L'injection de dépendances
Le mécanisme central d'ASP.NET Core, et les durées de vie qui font tomber les applications.
Configuration, options, logs
appsettings, secrets, IOptions, journalisation structurée.
HTTP, hosting et middleware
Ce qui se passe entre le clic du navigateur et ton code. L'ordre compte.
Minimal API
Construire une API propre : routes, binding, validation, OpenAPI, erreurs, pagination.
EF Core : la base de données
Modéliser, migrer, interroger — et ne pas générer 400 requêtes SQL sans le savoir.
Blazor : l'interface en C#
Composants, modes de rendu, cycle de vie, formulaires, état, interop JavaScript.
Sécurité : identité et accès
Authentifier, autoriser, cookies vs jetons, passkeys, CSRF, secrets.
Tester son code
Unitaire, intégration, doublures, API en mémoire, composants Blazor.
Performance et diagnostic
Mesurer avant d'optimiser : allocations, cache, télémétrie, profils.
Publier et déployer
Publication, conteneurs, AOT, variables d'environnement, santé de l'application.
Tout .NET 10
Sorti en novembre 2025, supporté jusqu'en novembre 2028. Le socle recommandé aujourd'hui.
Tout .NET 11
Prévu le 10 novembre 2026 (STS). Unions C# 15, runtime async, EF 11.
Sur quelle version faut-il être ?
En pratique aujourd'hui : développe sur .NET 10. C'est la version soutenue longtemps, celle des modèles de projet par défaut, celle que cette documentation utilise dans tous ses exemples. Le chapitre 22 sur .NET 11 sert à savoir ce qui arrive, à tester en local — pas à mettre en production avant sa sortie.
Les nouveautés de .NET 11 décrites ici correspondent aux versions d'aperçu publiées au premier semestre 2026 (jusqu'à la Preview 6). Un aperçu, par définition, peut encore changer : une API peut être renommée ou retirée avant novembre. Les chapitres de fond (1 à 20) portent sur .NET 10 et restent valables.
Conventions utilisées
Blocs de code
Toujours du C# compilable dans le contexte indiqué, avec un bouton Copier au survol. Les commentaires en français expliquent la ligne importante.
Ce que cette documentation ne fait pas
- Elle ne remplace pas la référence d'API. Pour la liste exhaustive des surcharges de
Enumerable.GroupBy, va sur learn.microsoft.com/dotnet/api. Ici, on explique quand et pourquoi, pas tous les paramètres. - Elle ne couvre pas le desktop (WPF, WinForms, MAUI) ni le jeu vidéo (Unity), sauf mentions ponctuelles : le fil rouge est le développement web et service.
- Elle n'est pas un tutoriel pas-à-pas unique. Chaque chapitre est autonome et peut être lu seul, quitte à répéter une notion — c'est volontaire, pour la relecture.