Formation développement .NET

Leçon 1 • Collections et itération

Explorez les tableaux, les listes et les dictionnaires ainsi que les modèles d'itération. Prépare les apprenants à gérer des ensembles de données dans une logique applicative réelle.

Leçon 2 • Gestion des erreurs et débogage

Couvre les types d'exceptions, les blocs try-catch-finally et l'utilisation du débogueur Visual Studio. Permet aux apprenants de diagnostiquer et de se remettre des échecs d'exécution.

Leçon 3 • Présentation de l'écosystème .NET

Couvre le runtime, le SDK et la chaîne d'outils CLI qui animent les applications .NET. Établit le modèle mental de la plateforme nécessaire pour chaque chapitre suivant.

Leçon 4 • Syntaxe de base du langage C#

Présente les variables, les types de données, les opérateurs et le flux de contrôle. Fournit les bases syntaxiques requises avant d'aborder la conception orientée objet.

Leçon 1 • Héritage et polymorphisme

Enseigne les relations entre classes de base et classes dérivées, la substitution de méthodes et la distribution virtuelle. Permet aux apprenants de modéliser proprement des concepts hiérarchiques du domaine.

Leçon 2 • Classes, objets et constructeurs

Définit l'anatomie des classes, l'instanciation d'objets et la surcharge de constructeurs. Ancre les concepts POO dans une syntaxe C# concrète avant de passer à l'héritage.

Leçon 3 • Interfaces et contrats

Explique la déclaration d'interface, l'implémentation et les membres d'interface par défaut. Fait le pont entre la conception POO et le principe d'inversion de dépendances utilisé dans les chapitres suivants.

Leçon 4 • Principes SOLID en pratique

Applique les cinq principes SOLID pour refactoriser des classes mal conçues. Prépare les apprenants aux modèles architecturaux présentés dans les chapitres suivants.

Leçon 1 • Correspondance de modèles et enregistrements

Explore les expressions switch, les modèles positionnels et les types d'enregistrement pour les données immuables. Modernise le style de code et réduit le code passe-partout dans les modèles de domaine.

Leçon 2 • Génériques et contraintes de type

Enseigne les classes génériques, les méthodes et la syntaxe des contraintes pour la sécurité de type. Permet de créer des algorithmes réutilisables sans sacrifier la correction à la compilation.

Leçon 3 • Délégués, événements et expressions lambda

Couvre les types de délégués, les délégués multicast, les modèles d'événements et les expressions lambda. Établit les blocs de construction fonctionnels utilisés dans le code LINQ et asynchrone.

Leçon 4 • Requêtes et opérateurs LINQ

Présente la syntaxe de requête et la syntaxe de méthode pour filtrer, projeter et agréger des données. Permet directement les modèles d'accès aux données couverts dans le chapitre Entity Framework.

Leçon 1 • Programmation asynchrone avec async/await

Explique le modèle asynchrone basé sur les tâches et la compilation de machines à états. Permet aux apprenants d'écrire du code lié aux E/S sans bloquer les threads.

Leçon 2 • Modèles de la bibliothèque parallèle de tâches

Couvre Parallel.For, Parallel.ForEach et Task.WhenAll pour le travail lié au processeur. Relie la décomposition parallèle à des scénarios réels de traitement de données.

Leçon 3 • Canaux et pipelines de flux de données

Présente System.Threading.Channels et TPL Dataflow pour les pipelines producteur-consommateur. Prépare les apprenants aux architectures de streaming à haut débit.

Leçon 1 • Relations et propriétés de navigation

Modélise les relations un-à-plusieurs, plusieurs-à-plusieurs et un-à-un dans EF Core. Garantit un comportement correct des clés étrangères et de la cascade dans les modèles de domaine complexes.

Leçon 2 • Migrations et gestion du schéma

Enseigne la création, l'application et l'annulation de migrations pour gérer le schéma de base de données. Relie la modélisation code-first aux flux de travail de déploiement réels.

Leçon 3 • DbContext et configuration des entités

Couvre la configuration de DbContext, les classes d'entités et la configuration de l'API Fluent. Établit la base du modèle de données pour toutes les opérations EF Core suivantes.

Leçon 4 • Performances et modèles EF avancés

Aborde la division des requêtes, les requêtes compilées et le modèle de dépôt. Optimise le débit de la couche de données et découple la persistance de la logique métier.

Leçon 1 • Configuration et modèle d'options

Enseigne appsettings.json, les variables d'environnement et le modèle IOptions<T>. Permet une configuration spécifique à l'environnement sans modification du code.

Leçon 2 • Conteneur d'injection de dépendances intégré

Couvre l'enregistrement des services, les durées de vie et l'injection par constructeur dans .NET. Établit la base IoC qui sous-tend chaque application ASP.NET Core.

Leçon 3 • Architecture en couches et propre

Structure les projets en couches domaine, application, infrastructure et présentation. Applique des règles de dépendance qui maintiennent la logique métier libre de tout souci lié au framework.

Leçon 4 • Modèle MediatR et CQRS

Implémente la ségrégation responsabilité commande-requête à l'aide des gestionnaires MediatR. Découple la gestion des requêtes des contrôleurs et simplifie les préoccupations transversales.

Leçon 1 • Documentation d'API et gestion de versions

Intègre la documentation OpenAPI/Swagger et la gestion de versions d'API basée sur l'URL. Améliore l'expérience développeur et prend en charge une évolution rétrocompatible de l'API.

Leçon 2 • Pipeline de requête ASP.NET Core

Explique l'intergiciel, le générateur d'hôte et le cycle de vie des requêtes HTTP. Fournit le contexte architectural nécessaire pour configurer toute application ASP.NET Core.

Leçon 3 • API basées sur les contrôleurs et API minimales

Compare le routage par attribut ApiController avec le mappage de points de terminaison d'API minimale. Permet aux apprenants de choisir le style d'API approprié pour chaque contexte de projet.

Leçon 4 • Authentification et autorisation

Implémente l'authentification par jeton JWT et l'autorisation basée sur des stratégies dans les API. Sécurise les points de terminaison contre les accès non autorisés à l'aide de modèles standard du secteur.

Leçon 1 • Flux de travail du développement piloté par les tests

Applique les cycles rouge-vert-refactor pour piloter l'implémentation des fonctionnalités à partir des tests. Construit des habitudes disciplinées qui réduisent les taux de défauts dans le code de production.

Leçon 2 • Test unitaire avec xUnit et Moq

Couvre l'anatomie des tests xUnit, les assertions et le moquage des dépendances avec Moq. Valide des unités de logique individuelles isolément de l'infrastructure.

Leçon 3 • Test d'intégration des API ASP.NET Core

Utilise WebApplicationFactory pour lancer des serveurs de test in-process pour les tests d'API. Valide les pipelines de requête complets, y compris les interactions avec l'intergiciel et la base de données.

Leçon 4 • Observabilité et surveillance de l'état

Intègre la journalisation structurée, le traçage distribué et les points de terminaison de vérification de l'état. Fournit la visibilité opérationnelle nécessaire pour diagnostiquer les problèmes en production.