Sommaire

• Chapitre 1 : Introduction Comprendre C#, .NET et votre premier environnement

  • 1.1 Qu’est-ce que .NET
  • 1.1.1 .NET Framework Windows seulement hérité
  • 1.1.2 .NET Core multiplateforme moderne
  • 1.1.3 .NET 5, 6, 7, 8 plateforme unifiée
  • 1.1.4 .NET Standard contrat de compatibilité API
  • 1.2 Installer le SDK .NET
  • 1.2.1 Télécharger depuis dotnet.microsoft.com
  • 1.2.2 Vérifier l’installation avec dotnet info
  • 1.2.3 SDK vs Runtime
  • 1.3 Structure d’un projet
  • 1.3.1 fichier csproj format XML références de paquets
  • 1.3.2 Program.cs point d’entrée
  • 1.3.3 appsettings.json configuration
  • 1.3.4 dossiers obj et bin
  • 1.4 L’interface de ligne de commande dotnet
  • 1.4.1 dotnet new créer un projet à partir d’un modèle
  • 1.4.2 dotnet build compiler
  • 1.4.3 dotnet run compiler et exécuter
  • 1.4.4 dotnet test exécuter les tests unitaires
  • 1.4.5 dotnet publish produire une sortie déployable
  • 1.5 Instructions de niveau supérieur C# 9 et ultérieur
  • 1.5.1 Pas de méthode Main explicite
  • 1.5.2 Directives using implicites
  • 1.5.3 Quand utiliser vs Main traditionnel
  • 1.6 Votre première application console Bonjour le monde
  • 1.6.1 Créer le projet dotnet new console n HelloWorld
  • 1.6.2 Écrire Console.WriteLine Bonjour le monde
  • 1.6.3 Exécuter et observer la sortie
  • 1.7 Projet Outil de salutation en ligne de commande
  • 1.7.1 Idée : demander le nom et la couleur préférée, afficher un message
  • 1.7.2 Structure de dossiers GreetingTool Program.cs
  • 1.7.3 Étapes : demander le nom, demander la couleur, afficher un message personnalisé
• Chapitre 2 : Types primitifs et syntaxe de base

  • 2.1 Types valeur
  • 2.1.1 Types entiers
  • 2.2 Types référence
  • 2.2.1 string
  • 2.2.2 object
  • 2.2.3 dynamic
  • 2.3 Variables et constantes
  • 2.3.1 Déclaration type nomVariable
  • 2.3.2 Initialisation int x = 5
  • 2.3.3 Inférence de type avec var
  • 2.3.4 Constantes const double Pi = 3.14
  • 2.3.5 Champs readonly
  • 2.4 Interpolation de chaînes
  • 2.4.1 Syntaxe Bonjour nom
  • 2.4.2 Mise en forme valeur format
  • 2.4.3 Séquences d’échappement pour accolade littérale
  • 2.5 Entrées-sorties basiques
  • 2.5.1 Console.WriteLine ligne
  • 2.5.2 Console.Write sans saut de ligne
  • 2.5.3 Console.ReadLine retourne une chaîne
  • 2.5.4 Console.ReadKey un seul caractère
  • 2.6 Conversion de types
  • 2.6.1 Conversion implicite
  • 2.6.2 Conversion explicite
  • 2.6.3 Classe Convert
  • 2.6.4 Parse et TryParse
  • 2.7 Projet Calculatrice simple
• Chapitre 3 : Flux de contrôle et opérateurs

  • 3.1 Instructions conditionnelles
  • 3.1.1 if
  • 3.1.2 else if enchaîné
  • 3.1.3 else
  • 3.1.4 if imbriqué
  • 3.2 Instruction switch
  • 3.2.1 switch avec motifs constants
  • 3.2.2 switch avec critères de correspondance C# 7 et ultérieur
  • 3.2.3 Gardes when
  • 3.2.4 goto case rare
  • 3.3 Expressions switch C# 8 et ultérieur
  • 3.3.1 syntaxe
  • 3.3.2 modèle d’abandon
  • 3.4 Boucles
  • 3.4.1 for
  • 3.4.2 foreach
  • 3.4.3 while
  • 3.4.4 do while
  • 3.5 Contrôle de boucle
  • 3.5.1 break
  • 3.5.2 continue
  • 3.5.3 return
  • 3.5.4 goto à éviter
  • 3.6 Opérateurs
  • 3.6.1 Arithmétiques
  • 3.6.2 Assignation
  • 3.6.3 Logiques
  • 3.6.4 Comparaison
  • 3.6.5 Null coalescing
  • 3.6.6 Null conditionnel
  • 3.6.7 Ternaire
  • 3.6.8 Binaires
  • 3.7 Projet Jeu du nombre mystère
• Chapitre 4 : Programmation orientée objet (POO) en profondeur

  • 4.1 Classes et objets
  • 4.1.1 Définition d’une classe
  • 4.1.2 Instanciation
  • 4.1.3 Champs
  • 4.1.4 Propriétés
  • 4.1.5 Méthodes
  • 4.2 Encapsulation
  • 4.2.1 Modificateurs d’accès
  • 4.2.2 Accesseurs de propriétés
  • 4.2.3 Propriétés auto-implémentées
  • 4.3 Héritage
  • 4.3.1 Classe de base et classe dérivée
  • 4.3.2 Mot-clé base
  • 4.3.3 Classes sealed
  • 4.3.4 Méthodes virtual et override
  • 4.3.5 Classes et méthodes abstract
  • 4.3.6 Masquer des membres avec new
  • 4.4 Polymorphisme
  • 4.4.1 Polymorphisme à la compilation (surcharge)
  • 4.4.2 Polymorphisme à l’exécution (virtual/override)
  • 4.4.3 Opérateurs is et as
  • 4.5 Interfaces
  • 4.5.1 Définition d’une interface
  • 4.5.2 Implémenter une interface
  • 4.5.3 Implémentation explicite d’interface
  • 4.5.4 Méthodes d’interface par défaut C# 8 et ultérieur
  • 4.6 Classes et membres static
  • 4.6.1 Champs, méthodes, propriétés static
  • 4.6.2 Constructeur static
  • 4.6.3 Classe static ne peut pas être instanciée
  • 4.7 Projet Système de gestion de bibliothèque (console)
• Chapitre 5 : Patrons de conception pour le développement backend

  • 5.1 Patrons de création
  • 5.1.1 Fabrique (Factory Method)
  • 5.1.2 Fabrique abstraite (Abstract Factory)
  • 5.1.3 Singleton
  • 5.1.4 Monteur (Builder)
  • 5.1.5 Prototype
  • 5.2 Patrons structurels
  • 5.2.1 Adaptateur (Adapter)
  • 5.2.2 Proxy
  • 5.2.3 Décorateur (Decorator)
  • 5.2.4 Façade (Facade)
  • 5.2.5 Pont (Bridge)
  • 5.2.6 Composite
  • 5.2.7 Poids-mouche (Flyweight)
  • 5.3 Patrons comportementaux
  • 5.3.1 Stratégie (Strategy)
  • 5.3.2 Commande (Command)
  • 5.3.3 Observateur (Observer)
  • 5.3.4 Chaîne de responsabilité (Chain of Responsibility)
  • 5.3.5 Médiateur (Mediator)
  • 5.3.6 Memento
  • 5.3.7 État (State)
  • 5.3.8 Patron Méthode (Template Method)
  • 5.3.9 Visiteur (Visitor)
  • 5.4 Patrons architecturaux pour le backend
  • 5.4.1 Dépôt (Repository)
  • 5.4.2 Middleware
  • 5.4.3 Injection de dépendances
  • 5.5 Projet Système de remise avec le patron Stratégie
• Chapitre 6 : Système de types avancé

  • 6.1 Enregistrements (Records)
  • 6.1.1 record class
  • 6.1.2 record struct
  • 6.1.3 Enregistrements positionnels
  • 6.1.4 Expressions with
  • 6.1.5 Égalité basée sur la valeur
  • 6.2 Structures (struct)
  • 6.2.1 struct
  • 6.2.2 readonly struct
  • 6.2.3 ref struct
  • 6.2.4 Quand utiliser struct vs class
  • 6.3 Énumérations (enum)
  • 6.3.1 Définition d’une enum
  • 6.3.2 Type sous-jacent
  • 6.3.3 Enum avec attribut Flags
  • 6.3.4 Enum.Parse et Enum.GetValues
  • 6.4 Types référence Nullable C# 8 et ultérieur
  • 6.4.1 string? référence nullable
  • 6.4.2 Contexte d’annotation nullable
  • 6.4.3 Opérateur de suppression de null
  • 6.4.4 Avertissements de nullabilité
  • 6.5 Filtrage (Pattern matching)
  • 6.5.1 Motif constant
  • 6.5.2 Motif de type
  • 6.5.3 Motif de propriété
  • 6.5.4 Motif positionnel
  • 6.5.5 Motif de liste C# 11
  • 6.5.6 Motif var
  • 6.6 Projet Enregistrement Personne immuable avec validation
• Chapitre 7 : Délégués, événements et expressions lambda

  • 7.1 Délégués
  • 7.1.1 Déclaration
  • 7.1.2 Instanciation et invocation
  • 7.1.3 Délégués multicast
  • 7.1.4 Délégués génériques Action Func Predicate
  • 7.2 Événements
  • 7.2.1 Mot-clé event
  • 7.2.2 Souscription et désabonnement
  • 7.2.3 Invocation d’événement
  • 7.2.4 Patron standard EventHandler et EventArgs
  • 7.3 Expressions lambda
  • 7.3.1 Syntaxe
  • 7.3.2 Lambdas avec corps d’instructions
  • 7.3.3 Capture de variables externes (fermetures)
  • 7.3.4 Arbres d’expressions
  • 7.4 Fonctions anonymes
  • 7.4.1 Mot-clé delegate avant les lambdas
  • 7.4.2 Comparaison avec les lambdas
  • 7.5 Projet Simulateur de clic de bouton (événement)
• Chapitre 8 : LINQ (Language Integrated Query)

  • 8.1 Syntaxe de requête vs syntaxe de méthode
  • 8.1.1 Syntaxe de requête
  • 8.1.2 Syntaxe de méthode
  • 8.1.3 Mélange des deux
  • 8.2 Exécution différée vs immédiate
  • 8.2.1 Opérateurs différés
  • 8.2.2 Opérateurs immédiats
  • 8.2.3 Opérateurs de flux vs tampon
  • 8.3 LINQ to Objects, LINQ to XML, LINQ to Entities
  • 8.3.1 Collections en mémoire
  • 8.3.2 XML
  • 8.3.3 EF Core traduction SQL
  • 8.4 Opérateurs courants
  • 8.4.1 Filtrage
  • 8.4.2 Projection
  • 8.4.3 Tri
  • 8.4.4 Regroupement
  • 8.4.5 Jointure
  • 8.4.6 Agrégation
  • 8.4.7 Opérateurs d’élément
  • 8.4.8 Opérateurs ensemblistes
  • 8.4.9 Quantificateurs
  • 8.4.10 Partitionnement
  • 8.5 Projet Analyse de données employés
• Chapitre 9 : Programmation asynchrone (async/await)

  • 9.1 Modèle asynchrone basé sur les tâches (TAP)
  • 9.1.1 Task sans résultat
  • 9.1.2 Task avec résultat
  • 9.1.3 ValueTask et ValueTask pour la performance
  • 9.2 async et await
  • 9.2.1 Marquer une méthode async
  • 9.2.2 await extrait le résultat
  • 9.2.3 Transformation par le compilateur en machine à états
  • 9.3 Types de retour des méthodes async
  • 9.3.1 Task pour async void
  • 9.3.2 Task pour retourner une valeur
  • 9.3.3 void uniquement pour les gestionnaires d’événements (à éviter)
  • 9.4 Flux asynchrones
  • 9.4.1 IAsyncEnumerable
  • 9.4.2 await foreach
  • 9.4.3 await using pour disposer de manière asynchrone
  • 9.5 Éviter async void
  • 9.5.1 Les exceptions ne peuvent pas être capturées
  • 9.5.2 Difficile à tester
  • 9.6 ConfigureAwait(false)
  • 9.6.1 Éviter de capturer le SynchronizationContext d’origine
  • 9.6.2 Utiliser dans le code de bibliothèque
  • 9.7 Jetons d’annulation
  • 9.7.1 CancellationTokenSource
  • 9.7.2 CancellationToken
  • 9.7.3 ThrowIfCancellationRequested
  • 9.7.4 Annulation coopérative
  • 9.8 Projet Récupérateur de météo asynchrone
• Chapitre 10 : Gestion de la mémoire et performance

  • 10.1 Garbage collection (GC)
  • 10.1.1 Générations 0, 1, 2
  • 10.1.2 GC station de travail vs GC serveur
  • 10.1.3 GC d’arrière-plan
  • 10.1.4 Tas des grands objets (LOH)
  • 10.1.5 Objets épinglés
  • 10.2 IDisposable
  • 10.2.1 Ressources non managées
  • 10.2.2 Patron Dispose
  • 10.2.3 Instruction using
  • 10.2.4 await using et IAsyncDisposable
  • 10.3 Span et Memory
  • 10.3.1 Span réservé à la pile
  • 10.3.2 Memory pour le tas ou l’asynchrone
  • 10.3.3 ArrayPool pour louer des tampons
  • 10.4 Benchmarking
  • 10.4.1 BenchmarkDotNet
  • 10.4.2 Attributs Benchmark et MemoryDiagnoser
  • 10.4.3 Exécuter des benchmarks et éviter les pièges courants
  • 10.5 Projet Comparer concaténation de chaînes vs StringBuilder
• Chapitre 11 : Génériques et contraintes

  • 11.1 Classes génériques
  • 11.1.1 Syntaxe
  • 11.1.2 Nom des paramètres de type T, TKey, TValue
  • 11.2 Méthodes génériques
  • 11.2.1 T MaMéthode(T param)
  • 11.2.2 Inférence de type à l’appel
  • 11.3 Interfaces génériques
  • 11.3.1 interface IRepository
  • 11.3.2 Covariance (out T) et contravariance (in T)
  • 11.4 Contraintes
  • 11.4.1 where T : struct (type valeur)
  • 11.4.2 where T : class (type référence)
  • 11.4.3 where T : new() (constructeur sans paramètre)
  • 11.4.4 where T : BaseClass (contrainte de classe de base)
  • 11.4.5 where T : IMyInterface (contrainte d’interface)
  • 11.4.6 where T : unmanaged (sans références)
  • 11.4.7 Contraintes multiples
  • 11.5 Projet Simulateur de dépôt générique
• Chapitre 12 : Exceptions et gestion des erreurs

  • 12.1 try/catch/finally
  • 12.1.1 Capturer des types d’exception spécifiques
  • 12.1.2 Blocs catch multiples
  • 12.1.3 finally pour le nettoyage
  • 12.2 Filtres d’exception
  • 12.2.1 catch avec condition when
  • 12.3 Exceptions personnalisées
  • 12.3.1 Dériver de Exception ou ApplicationException
  • 12.3.2 Constructeur de sérialisation
  • 12.3.3 Ajouter des propriétés personnalisées
  • 12.4 ExceptionDispatchInfo
  • 12.4.1 Capturer et relancer avec la pile d’appels d’origine
  • 12.5 Gestion globale des exceptions
  • 12.5.1 Middleware ASP.NET Core
  • 12.5.2 AppDomain.UnhandledException
  • 12.5.3 TaskScheduler.UnobservedTaskException
  • 12.6 Projet Lecteur de fichier sécurisé avec réessai
• Chapitre 13 : Réflexion, attributs et générateurs sources

  • 13.1 Réflexion
  • 13.1.1 Classe Type
  • 13.1.2 Chargement et analyse d’assembly
  • 13.1.3 MemberInfo, MethodInfo, PropertyInfo
  • 13.1.4 Invoquer des méthodes dynamiquement
  • 13.2 Attributs personnalisés
  • 13.2.1 Classe d’attribut avec AttributeUsage
  • 13.2.2 Appliquer des attributs aux cibles
  • 13.2.3 Lire des attributs avec la réflexion
  • 13.3 Générateurs sources
  • 13.3.1 Que sont les générateurs sources ?
  • 13.3.2 Générateurs incrémentaux
  • 13.3.3 Cas d’usage (code à la compilation, performance)
  • 13.3.4 Différence avec la réflexion (aucun coût à l’exécution)
  • 13.4 Projet Moteur de validation basé sur attributs
• Chapitre 14 : Fonctionnalités modernes de C# pour le backend

  • 14.1 Accesseurs init uniquement
  • 14.1.1 Objets immuables après construction
  • 14.1.2 Initialiseur d’objet avec init
  • 14.2 Membres required C# 11
  • 14.2.1 Mot-clé required
  • 14.2.2 Le constructeur garantit que les propriétés required sont définies
  • 14.3 Types record (rappel)
  • 14.4 Gestionnaires de chaînes interpolées
  • 14.4.1 Optimisation des performances pour la journalisation
  • 14.4.2 Structure InterpolatedStringHandler
  • 14.5 Attributs d’informations d’appelant
  • 14.5.1 CallerMemberName
  • 14.5.2 CallerArgumentExpression
  • 14.5.3 CallerFilePath et CallerLineNumber
  • 14.6 Projet Aide à la journalisation avec informations d’appelant
• Chapitre 15 : Tests et simulation (mocking)

  • 15.1 Frameworks de tests unitaires
  • 15.1.1 xUnit (Fact, Theory, InlineData)
  • 15.1.2 NUnit (Test, TestCase)
  • 15.1.3 MSTest
  • 15.2 Bibliothèques de simulation
  • 15.2.1 Moq (Mock, Setup, Verify)
  • 15.2.2 NSubstitute (Substitute.For())
  • 15.2.3 FakeItEasy
  • 15.3 Doubles de test
  • 15.3.1 Stub
  • 15.3.2 Mock
  • 15.3.3 Fake
  • 15.4 Tests d’intégration
  • 15.4.1 WebApplicationFactory
  • 15.4.2 Base de données en mémoire avec EF Core
  • 15.4.3 HttpClient pour tester les endpoints
  • 15.5 Projet Tester un service de calculatrice avec Moq
• Chapitre 16 : Journalisation, diagnostic et configuration

  • 16.1 Journalisation
  • 16.1.1 Interface ILogger
  • 16.1.2 Niveaux de log : Trace, Debug, Information, Warning, Error, Critical
  • 16.1.3 Journalisation structurée avec Serilog, NLog
  • 16.1.4 Enrichissement et destinations (console, fichier, Elasticsearch)
  • 16.2 Configuration
  • 16.2.1 IConfiguration et fournisseurs de configuration
  • 16.2.2 Fichiers JSON (appsettings.json)
  • 16.2.3 Variables d’environnement
  • 16.2.4 Secrets utilisateur (développement uniquement)
  • 16.2.5 Arguments de ligne de commande
  • 16.3 Patron Options
  • 16.3.1 IOptions singleton, pas de rechargement
  • 16.3.2 IOptionsSnapshot par portée, rechargement au changement
  • 16.3.3 IOptionsMonitor singleton avec notifications de changement
  • 16.3.4 Configure et PostConfigure
  • 16.4 Projet Application configurable avec Serilog
• Chapitre 17 : Injection de dépendances en profondeur

  • 17.1 Durées de vie des services
  • 17.1.1 Singleton (une instance pour toute l’application)
  • 17.1.2 Scoped (une par requête HTTP ou portée)
  • 17.1.3 Transient (nouvelle instance à chaque fois)
  • 17.2 Méthodes d’enregistrement
  • 17.2.1 AddSingleton, AddScoped, AddTransient
  • 17.2.2 Délégués d’usine
  • 17.2.3 Enregistrements génériques ouverts
  • 17.3 Résolution de services
  • 17.3.1 Injection par constructeur (préférée)
  • 17.3.2 IServiceProvider directement
  • 17.3.3 IServiceScopeFactory pour créer des portées
  • 17.4 Patron Décorateur avec DI
  • 17.4.1 Utiliser AddScoped pour envelopper un service
  • 17.4.2 Bibliothèque Scrutor pour les décorateurs
  • 17.5 Projet Démonstrateur de durées de vie DI
• Chapitre 18 : Interopérabilité et API bas niveau

  • 18.1 P/Invoke
  • 18.1.1 Attribut DllImport (hérité)
  • 18.1.2 LibraryImport (générateur source, .NET 7 et ultérieur)
  • 18.1.3 Marshalling des chaînes, structures, pointeurs
  • 18.2 Code non vérifié (unsafe)
  • 18.2.1 Contexte unsafe
  • 18.2.2 Pointeurs
  • 18.2.3 Instruction fixed pour épingler des objets managés
  • 18.2.4 stackalloc pour allouer sur la pile
  • 18.3 Fichiers mappés en mémoire
  • 18.3.1 MemoryMappedFile.CreateFromFile
  • 18.3.2 MemoryMappedViewAccessor
  • 18.4 Classe Marshal
  • 18.4.1 Marshal.AllocHGlobal (mémoire non managée)
  • 18.4.2 Marshal.StructureToPtr
  • 18.4.3 Marshal.PtrToStructure
  • 18.5 Projet Appeler la MessageBox Windows via P/Invoke
• Chapitre 19 : Patrons spécifiques au backend

  • 19.1 Pipeline de middleware
  • 19.1.1 Use (court-circuit)
  • 19.1.2 Run (terminal middleware)
  • 19.1.3 Map (branchement)
  • 19.1.4 Ordre des middlewares
  • 19.2 Délégués de requête
  • 19.2.1 Signature RequestDelegate
  • 19.2.2 Middleware inline avec Use
  • 19.3 Middleware personnalisé
  • 19.3.1 Classe avec méthode InvokeAsync
  • 19.3.2 Injection de services (scoped, singleton)
  • 19.3.3 Appeler _next(context)
  • 19.4 Projet Middleware de journalisation des requêtes personnalisé
• Chapitre 20 : Qualité de code et outils

  • 20.1 Analyseurs Roslyn
  • 20.1.1 FxCop (hérité) et Microsoft.CodeAnalysis.NetAnalyzers
  • 20.1.2 StyleCop (nommage, mise en page)
  • 20.1.3 SonarAnalyzer (sécurité, bogues)
  • 20.2 Formatage
  • 20.2.1 Fichier editorconfig
  • 20.2.2 Commande dotnet format
  • 20.2.3 Intégration IDE (VS, Rider, VS Code)
  • 20.3 Crochets de pré-commit
  • 20.3.1 Husky.NET ou scripts bash simples
  • 20.3.2 Exécuter dotnet format et dotnet test avant le commit
  • 20.4 Projet Appliquer des normes de codage avec editorconfig
• Chapitre 21 : Internals du CLR et diagnostics

  • 21.1 Compilation JIT
  • 21.1.1 Compilation à plusieurs niveaux (Tiered)
  • 21.1.2 ReadyToRun (R2R) précompilation
  • 21.1.3 Cross-gen (fichier unique, Native AOT)
  • 21.2 Outils de diagnostic
  • 21.2.1 dotnet trace (événements runtime, profilage)
  • 21.2.2 dotnet dump (analyse du tas, vidages de crash)
  • 21.2.3 dotnet counters (compteurs de performance)
  • 21.2.4 dotnet gcdump (instantanés du tas GC)
  • 21.3 Écouteurs d’événements
  • 21.3.1 EventSource (événements personnalisés)
  • 21.3.2 EventListener (consommer des événements)
  • 21.3.3 DiagnosticSource (pour l’instrumentation de bibliothèque)
  • 21.4 Projet Collecter les événements GC avec EventListener
• Chapitre 22 : Concurrence bas niveau et code sans verrou

  • 22.1 Rappels sur les threads
  • 22.1.1 System.Threading.Thread
  • 22.1.2 ThreadPool
  • 22.1.3 Task comme abstraction de plus haut niveau
  • 22.2 Primitives sans verrou
  • 22.2.1 Classe Interlocked
  • 22.2.2 Volatile (empêcher les optimisations du compilateur)
  • 22.2.3 MemoryBarrier (rarement nécessaire directement)
  • 22.3 Synchronisation légère
  • 22.3.1 SpinLock (quand le verrou est tenu brièvement)
  • 22.3.2 SpinWait (attente hybride)
  • 22.3.3 Lazy avec initialisation thread-safe
  • 22.3.4 LazyInitializer (helpers statiques)
  • 22.4 Collections concurrentes
  • 22.4.1 ConcurrentDictionary
  • 22.4.2 ConcurrentQueue
  • 22.4.3 ConcurrentStack
  • 22.4.4 ConcurrentBag
  • 22.4.5 BlockingCollection
  • 22.4.6 Channel (producteur-consommateur, support asynchrone)
  • 22.5 Projet Compteur thread-safe avec Interlocked
• Chapitre 23 : Techniques avancées de test et débogage

  • 23.1 Test instantané (snapshot) avec Verify
  • 23.1.1 Sérialisation de la sortie attendue
  • 23.1.2 Comparaison des différences
  • 23.2 Fuzzing (entrées aléatoires)
  • 23.2.1 FsCheck pour les tests basés sur les propriétés
  • 23.2.2 Générer des valeurs arbitraires
  • 23.2.3 Réduction des contre-exemples
  • 23.3 Débogage avec WinDbg/SOS
  • 23.3.1 Attacher à un processus
  • 23.3.2 Commandes dumpheap et gcroot
  • 23.3.3 Analyser les interblocages, forte utilisation CPU
  • 23.4 Ingénierie du chaos (Chaos engineering)
  • 23.4.1 Simuler des pannes avec Polly (politiques de chaos)
  • 23.4.2 Injection de fautes dans les tests d’intégration
  • 23.5 Projet Test basé sur les propriétés pour un algorithme de tri
• Chapitre 24 : API REST en profondeur

  • 24.1 Contrôleurs vs API minimales
  • 24.1.1 Contrôleur (ApiController, Route)
  • 24.1.2 API minimales (MapGet, MapPost)
  • 24.1.3 Compromis (simplicité vs fonctionnalités)
  • 24.2 Routage et liaison de modèles
  • 24.2.1 Routage par attributs
  • 24.2.2 Contraintes de route
  • 24.2.3 From body, query, route, header
  • 24.3 Validation
  • 24.3.1 Annotations de données (Required, MaxLength)
  • 24.3.2 Validation automatique avec ApiController
  • 24.3.3 Attributs de validation personnalisés
  • 24.3.4 FluentValidation (bibliothèque externe)
  • 24.4 Négociation de contenu
  • 24.4.1 En-tête Accept
  • 24.4.2 Attributs Produces et Consumes
  • 24.4.3 Formateurs personnalisés
  • 24.5 Gestion de version d’API
  • 24.5.1 Versionnement par chemin d’URL
  • 24.5.2 Versionnement par chaîne de requête
  • 24.5.3 Versionnement par en-tête
  • 24.5.4 Microsoft.AspNetCore.Mvc.Versioning
  • 24.6 OpenAPI et Swagger
  • 24.6.1 Swashbuckle.AspNetCore
  • 24.6.2 Générer du JSON Swagger
  • 24.6.3 Interface Swagger UI pour les tests
  • 24.6.4 Annotations ProducesResponseType
  • 24.7 Problème Details (RFC 7807)
  • 24.7.1 Classe ProblemDetails
  • 24.7.2 ValidationProblemDetails pour les erreurs
  • 24.7.3 Results.Problem dans les API minimales
  • 24.8 Projet API Todo avec versionnement et OpenAPI
• Chapitre 25 : Sécurité des API en profondeur

  • 25.1 CORS
  • 25.1.1 Politique de même origine
  • 25.1.2 Requêtes préliminaires (OPTIONS)
  • 25.1.3 AddCors et UseCors
  • 25.1.4 Origines, méthodes, en-têtes autorisés
  • 25.1.5 Credentials (AllowCredentials)
  • 25.2 Limitation de débit (Rate limiting)
  • 25.2.1 Fenêtre fixe, fenêtre glissante, seau à jetons, concurrence
  • 25.2.2 Intégré à .NET 7 et ultérieur (AddRateLimiter, EnableRateLimiting)
  • 25.2.3 Partitionnement par utilisateur, IP, clé API
  • 25.2.4 Retourner 429 avec Retry-After
  • 25.3 En-têtes de sécurité
  • 25.3.1 HSTS (Strict-Transport-Security)
  • 25.3.2 CSP (Content-Security-Policy)
  • 25.3.3 X-Frame-Options (anti-clickjacking)
  • 25.3.4 X-Content-Type-Options (nosniff)
  • 25.3.5 Referrer-Policy
  • 25.4 Clés API
  • 25.4.1 En-tête ou chaîne de requête
  • 25.4.2 Gestionnaire d’authentification personnalisé
  • 25.4.3 Stocker les clés de manière sécurisée (Azure Key Vault, Data Protection)
  • 25.5 Signature HMAC
  • 25.5.1 Signature de la requête (le client calcule le hachage)
  • 25.5.2 Le serveur recalcule et compare
  • 25.5.3 Prévention des attaques par rejeu (nonce, horodatage)
  • 25.6 Protection des données (DPAPI)
  • 25.6.1 IDataProtectionProvider
  • 25.6.2 Protect et Unprotect
  • 25.6.3 Anneau de clés (stockage, rotation automatique)
  • 25.6.4 Chaînes d’objectif (clés isolées)
  • 25.7 Validation des entrées
  • 25.7.1 Anti-XSS intégré (insuffisant)
  • 25.7.2 FluentValidation pour les règles complexes
  • 25.7.3 Liste blanche vs liste noire
  • 25.8 OWASP Top 10 pour les API
  • 25.8.1 API1 : Autorisation au niveau objet défaillante
  • 25.8.2 API2 : Authentification défaillante
  • 25.8.3 API3 : Exposition excessive de données
  • 25.8.4 API4 : Manque de limitation de débit
  • 25.8.5 API5 : Autorisation au niveau fonction défaillante
  • 25.8.6 API6 : Assignment massif
  • 25.8.7 API7 : Mauvaise configuration de la sécurité
  • 25.8.8 API8 : Injection
  • 25.8.9 API9 : Mauvaise gestion des actifs
  • 25.8.10 API10 : Journalisation et surveillance insuffisantes
  • 25.9 Projet API météo sécurisée
• Chapitre 26 : Authentification dans ASP.NET Core

  • 26.1 Schémas d’authentification
  • 26.1.1 Authentification par cookie (applications web traditionnelles)
  • 26.1.2 JWT Bearer (jetons API)
  • 26.1.3 OAuth 2.0 et OpenID Connect (fournisseurs externes)
  • 26.2 Configuration
  • 26.2.1 AddAuthentication et AddJwtBearer
  • 26.2.2 Attribut Authorize
  • 26.2.3 Logique personnalisée avec AuthenticationHandler
  • 26.3 Détails sur JWT
  • 26.3.1 En-tête, charge utile, signature
  • 26.3.2 Émetteur, audience, expiration
  • 26.3.3 Signature symétrique (HMAC) vs asymétrique (RSA)
  • 26.4 Projet Authentification JWT pour l’API Todo
• Chapitre 27 : Autorisation basée sur les rôles, les politiques et les ressources

  • 27.1 Basée sur les rôles
  • 27.1.1 Authorize avec Roles
  • 27.1.2 Revendications (claims) avec type de rôle
  • 27.2 Basée sur les politiques
  • 27.2.1 AddAuthorization avec politiques
  • 27.2.2 RequireClaim, RequireRole, RequireAssertion
  • 27.2.3 IAuthorizationRequirement personnalisé et AuthorizationHandler
  • 27.3 Basée sur les ressources
  • 27.3.1 Injecter IAuthorizationService
  • 27.3.2 Appeler AuthorizeAsync avec utilisateur, ressource, exigence
  • 27.3.3 Dans un endpoint, vérifier la propriété
  • 27.4 Projet API Todo avec politiques de rôle et de propriété
• Chapitre 28 : Accès aux bases de données avec EF Core et Dapper

  • 28.1 EF Core
  • 28.1.1 DbContext, DbSet
  • 28.1.2 Migrations (Add-Migration, Update-Database)
  • 28.1.3 Requêtes LINQ traduites en SQL
  • 28.1.4 Suivi des modifications et SaveChanges
  • 28.1.5 Jetons de concurrence (Timestamp)
  • 28.2 Dapper
  • 28.2.1 QueryAsync (SQL brut)
  • 28.2.2 ExecuteAsync (non-requête)
  • 28.2.3 Multi-mappage
  • 28.2.4 Avantage de performance par rapport à EF Core
  • 28.3 Quand utiliser l’un ou l’autre
  • 28.3.1 EF Core pour les graphes d’objets complexes, migrations
  • 28.3.2 Dapper pour les requêtes en lecture seule haute performance
  • 28.3.3 Utiliser les deux ensemble (CQRS léger)
  • 28.4 Projet API de blog avec EF Core pour les écritures et Dapper pour les lectures
• Chapitre 29 : Entrées-sorties fichiers et flux pour les développeurs backend

  • 29.1 Aides du système de fichiers
  • 29.1.1 File, Directory, FileInfo, DirectoryInfo
  • 29.1.2 ReadAllText, WriteAllText (pratique mais charge tout le fichier)
  • 29.2 Flux (Streams)
  • 29.2.1 FileStream (lire/écrire des octets)
  • 29.2.2 StreamReader / StreamWriter (texte)
  • 29.2.3 MemoryStream (tampon en mémoire)
  • 29.2.4 GZipStream (compression)
  • 29.3 Réponses en streaming
  • 29.3.1 Results.Stream dans les API minimales
  • 29.3.2 FileStreamResult dans les contrôleurs
  • 29.3.3 Éviter de charger de gros fichiers en mémoire
  • 29.4 Projet API d’envoi et téléchargement de fichiers
• Chapitre 30 : Files d’attente de messages et architecture événementielle

  • 30.1 Courtiers de messages
  • 30.1.1 RabbitMQ (populaire, AMQP)
  • 30.1.2 Azure Service Bus (cloud)
  • 30.1.3 AWS SQS / SNS
  • 30.1.4 Kafka (débit élevé)
  • 30.2 Abstractions
  • 30.2.1 MassTransit (supporte plusieurs courtiers)
  • 30.2.2 NServiceBus (commercial)
  • 30.2.3 Bibliothèques client brutes
  • 30.3 Idempotence
  • 30.3.1 Clés d’idempotence dans les en-têtes de message
  • 30.3.2 Stocker les ID de messages traités
  • 30.3.3 Livraison exactement une fois (pas vraiment possible, mais consommateurs idempotents)
  • 30.4 Patron Outbox
  • 30.4.1 Stocker les messages dans la base de données dans la transaction
  • 30.4.2 Un processeur d’arrière-plan publie sur le courtier
  • 30.4.3 Empêche la perte de messages en cas de panne du courtier
  • 30.5 Files de lettres mortes (Dead-letter queues)
  • 30.5.1 Gérer les messages empoisonnés
  • 30.5.2 Politiques de réessai et lettre morte après un nombre maximal d’essais
  • 30.6 Projet Traitement de commandes avec RabbitMQ et MassTransit
• Chapitre 31 : gRPC pour des API haute performance

  • 31.1 Protocole Buffers (Protobuf)
  • 31.1.1 Syntaxe .proto pour messages et services
  • 31.1.2 Types scalaires (int32, string, bool)
  • 31.1.3 Champs répétés, énumérations, messages imbriqués
  • 31.2 Types de services gRPC
  • 31.2.1 Unaire (requête-réponse)
  • 31.2.2 Streaming serveur (plusieurs réponses)
  • 31.2.3 Streaming client (plusieurs requêtes)
  • 31.2.4 Streaming bidirectionnel
  • 31.3 Implémentation dans .NET
  • 31.3.1 Paquet Grpc.AspNetCore
  • 31.3.2 Génération de code à partir de .proto
  • 31.3.3 Implémentation du service (hérite de la classe générée)
  • 31.4 gRPC vs REST
  • 31.4.1 Performance (binaire, multiplexage HTTP/2)
  • 31.4.2 Contrat d’abord vs code d’abord
  • 31.4.3 gRPC-Web pour les clients navigateur
  • 31.5 Projet Service de streaming de prix d’actions
• Chapitre 32 : Communication temps réel avec SignalR

  • 32.1 Hubs
  • 32.1.1 Classe Hub
  • 32.1.2 Méthodes appelables par le client
  • 32.1.3 Appeler des méthodes client
  • 32.2 Gestion des connexions
  • 32.2.1 OnConnectedAsync et OnDisconnectedAsync
  • 32.2.2 Conserver les ID de connexion
  • 32.2.3 Logique de reconnexion
  • 32.3 Montée en charge
  • 32.3.1 Plan de données Redis (Redis backplane)
  • 32.3.2 Service Azure SignalR (entièrement géré)
  • 32.3.3 Sessions persistantes (si pas de plan de données)
  • 32.4 Transports
  • 32.4.1 WebSockets (meilleure performance)
  • 32.4.2 Server-Sent Events (SSE)
  • 32.4.3 Long polling (fallback)
  • 32.5 Projet Application de chat en direct
• Chapitre 33 : Docker et conteneurisation pour le backend .NET

  • 33.1 Bases de Docker
  • 33.1.1 Dockerfile : FROM, WORKDIR, COPY, RUN, EXPOSE, ENTRYPOINT
  • 33.1.2 Constructions multi-étapes (images de build vs runtime)
  • 33.1.3 .dockerignore
  • 33.2 Docker Compose
  • 33.2.1 docker-compose.yml (services, réseaux, volumes)
  • 33.2.2 Variables d’environnement
  • 33.2.3 Dépendances (depends_on)
  • 33.3 Tests de santé (Health checks)
  • 33.3.1 HEALTHCHECK dans le Dockerfile
  • 33.3.2 Health checks ASP.NET Core (AddHealthChecks)
  • 33.4 Projet Dockeriser l’API Todo avec PostgreSQL
• Chapitre 34 : CI/CD pour le backend .NET

  • 34.1 Plateformes CI/CD
  • 34.1.1 GitHub Actions
  • 34.1.2 Azure DevOps Pipelines
  • 34.1.3 GitLab CI
  • 34.1.4 Jenkins (hérité)
  • 34.2 Pipeline typique
  • 34.2.1 Build (dotnet build)
  • 34.2.2 Test (dotnet test)
  • 34.2.3 Publication (dotnet publish)
  • 34.2.4 Construction de l’image Docker (docker build)
  • 34.2.5 Pousser vers un registre (docker push)
  • 34.2.6 Déployer sur Azure Container Instances, Kubernetes, VM
  • 34.3 Infrastructure as Code
  • 34.3.1 Bicep (pour Azure Resource Manager)
  • 34.3.2 Terraform (multi-cloud)
  • 34.4 Projet CI/CD avec GitHub Actions pour l’API Todo
• Chapitre 35 : Capstone intermédiaire : API REST sécurisée avec contrôle d’accès basé sur les rôles et OTP

  • 35.1 Aperçu du projet
  • 35.2 Fonctionnalités : JWT, rôles, OTP, limitation de débit, idempotence
  • 35.3 Étapes d’implémentation
  • 35.3.1 Créer un projet ASP.NET Core avec JWT
  • 35.3.2 Implémenter l’enregistrement et la connexion des utilisateurs
  • 35.3.3 Ajouter des revendications de rôles et des endpoints administrateur
  • 35.3.4 Service de génération OTP (6 chiffres avec expiration)
  • 35.3.5 Service d’arrière-plan + canal pour l’envoi d’emails
  • 35.3.6 Middleware d’idempotence avec Redis
  • 35.3.7 Tests d’intégration
  • 35.3.8 Docker et CI/CD
  • 35.4 Livrables
• Chapitre 36 : Au-delà de senior : systèmes distribués, cloud natif et leadership

  • 36.1 Microservices vs monolithe modulaire
  • 36.1.1 Avantages et compromis
  • 36.1.2 Découverte de services (Consul, Eureka)
  • 36.1.3 Passerelles API (Ocelot, YARP, Kong)
  • 36.2 Transactions distribuées
  • 36.2.1 Commit en deux phases (peu courant dans les microservices)
  • 36.2.2 Patron Saga (chorégraphie vs orchestration)
  • 36.2.3 Idempotence et transactions compensatoires
  • 36.3 Patrons cloud natifs
  • 36.3.1 Réessai et disjoncteur (circuit breaker) avec Polly
  • 36.3.2 Patron Sidecar (par exemple Dapr)
  • 36.3.3 Tests de santé (health checks) et sondes de vivacité (liveness)
  • 36.4 Leadership
  • 36.4.1 Enregistrements de décision d’architecture (ADR)
  • 36.4.2 Mener des revues de conception technique
  • 36.4.3 Mentorat des ingénieurs seniors
  • 36.5 Projet ADR et preuve de concept pour le patron Saga
• Chapitre 37 : Projet final de maîtrise : Système bancaire central (Finance)

  • 37.1 Contexte métier
  • 37.2 Fonctionnalités principales : comptes, virements, intérêts, flux temps réel
  • 37.3 Défis techniques : idempotence, concurrence, outbox, traçage
  • 37.4 Structure de solution : monolithe modulaire
  • 37.5 Modèles de données
  • 37.6 Étapes d’implémentation
  • 37.6.1 Créer une solution avec quatre projets
  • 37.6.2 Définir les modèles de domaine et DbContext
  • 37.6.3 Implémenter un endpoint de virement idempotent
  • 37.6.4 Ajouter la concurrence optimiste (version de ligne)
  • 37.6.5 Configurer RabbitMQ et MassTransit
  • 37.6.6 Implémenter un hub SignalR pour les mises à jour de solde
  • 37.6.7 Workers d’arrière-plan (paiements programmés, intérêts, outbox)
  • 37.6.8 Ajouter des réessais Polly pour les notifications
  • 37.6.9 Configurer OpenTelemetry et Jaeger
  • 37.6.10 Écrire Docker Compose
  • 37.6.11 Écrire un test de charge k6
  • 37.6.12 Mettre en place CI/CD
  • 37.7 Livrables
  • 37.8 Extensions optionnelles

http://localhost:4321/en/docs/chapter-1-introduction-understanding-c-net-and-your-first-setup/1-1-what-is-net http://localhost:4321/en/chapter-1-introduction-understanding-c-net-and-your-first-setup/1-1-what-is-net