C#/.NET - Les fondamentaux du développement

Objectif : Comprendre le rôle du framework .NET et configurer son environnement de développement.

• Découvrir l'architecture de la plateforme .NET (.NET CLI, CLR, BCL).
• Créer et exécuter son premier projet console moderne via la ligne de commande.
• Maîtriser les types de données de base, les variables locales typées implicitement (var) et les constantes.
• Manipuler les opérateurs logiques, arithmétiques et les structures conditionnelles (if, switch, filtrage de motifs).

Atelier pratique : Initialisation d'une calculatrice financière console interactive.

Cas métier : Initialisation d'une calculatrice financière console interactive avec contrôle des types de variables et précision monétaire (decimal).

Compétence acquise : Être capable de configurer, compiler et exécuter un projet console élémentaire en C#.

Livrable : Premier programme C# exécutable et structuré.

Objectif : Structurer des algorithmes répétitifs et organiser des données en mémoire.

• Mettre en œuvre les boucles classiques (for, while, do-while) et l'itération sécurisée (foreach).
• Maîtriser la manipulation des chaînes de caractères avec l'interpolation moderne et le type optimisé StringBuilder.
• Utiliser les collections fondamentales de C# : tableaux à taille fixe, listes génériques (List<T>) et dictionnaires (Dictionary<K, V>).

Atelier pratique : Conception d'un utilitaire d'analyse de fréquences de mots et d'évaluation de fichiers de logs applicatifs.

Cas métier : Conception d'un utilitaire d'analyse de fréquences de mots et d'évaluation de fichiers de logs applicatifs (StringBuilder / Dictionary<K, V>).

Compétence acquise : Être capable d'organiser et de manipuler de grandes collections de données en mémoire.

Livrable : Algorithme d'analyse textuelle robuste et optimisé.

Objectif : Modéliser des entités du monde réel sous forme de classes et d'objets en C#.

• Définir des classes : membres, champs privés, propriétés auto-implémentées et propriétés en lecture seule.
• Maîtriser l'instanciation des objets et le rôle clé des constructeurs (constructeurs primaires).
• Comprendre la différence fondamentale entre les types référence (class, record) et les types valeur (struct, record struct).

Atelier pratique : Établissement de la couche métier orientée objet d'un gestionnaire d'identités et de rôles utilisateurs.

Cas métier : Établissement de la couche métier orientée objet d'un gestionnaire d'identités et de rôles utilisateurs avec types nullables et propriétés sécurisées (get ; init ; ).

Compétence acquise : Savoir appliquer le principe d'encapsulation pour protéger l'état de ses objets métiers.

Livrable : Bibliothèque de classes métiers modélisée selon les règles de l'art.

Objectif : Rendre le code flexible, générique et modulaire à l'aide de l'abstraction.

• Mettre en œuvre le mécanisme d'héritage pour factoriser le comportement des classes.
• Utiliser le polymorphisme, les méthodes virtuelles (virtual/override) et les classes abstraites.
• Définir et implémenter des interfaces pour poser des contrats logiciels réutilisables.

Atelier pratique : Création d'un moteur de calcul de facturation multi-canal gérant différents modes de paiement.

Cas métier : Création d'un moteur de calcul de facturation multi-canal gérant différents modes de paiement de manière polymorphique.

Compétence acquise : Être capable de concevoir des modules logiciels faiblement couplés et hautement réutilisables.

Livrable : Moteur de calcul orienté objet extensible sans modification du code existant.

Objectif : Découpler les classes et automatiser l'injection des services applicatifs.

• Comprendre le principe d'inversion de contrôle (IoC) et l'architecture découplée.
• Mettre en œuvre le moteur d'injection de dépendances natif de .NET.
• Configurer le cycle de vie des services injectés : Transient, Scoped et Singleton.

Atelier pratique : Refactorisation de l'application de facturation pour y injecter dynamiquement les modules de calcul de taxes et de notifications.

Cas métier : Refactorisation de l'application de facturation pour y injecter dynamiquement les modules de calcul de taxes et de notifications via le conteneur IoC .NET.

Compétence acquise : Maîtriser l'architecture moderne et l'injection de dépendances propre aux applications d'entreprise .NET.

Livrable : Architecture d'application propre, modulaire et hautement testable.

Objectif : Sécuriser les applications face aux pannes logicielles et aux erreurs imprévues.

• Maîtriser la gestion des exceptions avec les blocs de contrôle try, catch, finally.
• Créer et propager des classes d'exceptions personnalisées adaptées au domaine métier.
• Mettre en œuvre la journalisation (Logging) applicative normalisée avec l'interface ILogger de Microsoft.

Atelier pratique : Mise en place d'un système de monitoring et d'interception globale d'erreurs sur un service d'importation de fichiers clients.

Cas métier : Mise en place d'un système de monitoring et d'interception globale d'erreurs sur un service d'importation de fichiers clients avec ILogger et IDisposable.

Compétence acquise : Être en mesure de concevoir une application tolérante aux pannes et de tracer son comportement en production.

Livrable : Module d'importation de données résilient, sécurisé et auditable.

Objectif : Filtrer, trier et projeter des collections de données avec une syntaxe déclarative fluide.

• Comprendre les fondements de LINQ (programmation fonctionnelle, expressions Lambda, delegates).
• Manipuler la syntaxe des requêtes (Query Syntax) et la syntaxe des méthodes d'extension (Method Syntax).
• Utiliser les opérateurs clés de LINQ : Where, Select, OrderBy, GroupBy, Join, Any, All.

Atelier pratique : Conception d'un moteur de recherche et de statistiques internes sur une base d'employés d'entreprise.

Cas métier : Conception d'un moteur de recherche, de filtrage et de statistiques internes sur une base d'employés d'entreprise à l'aide d'expressions LINQ fluides.

Compétence acquise : Savoir interroger et manipuler de grands ensembles d'objets en mémoire de façon concise et optimisée.

Livrable : Moteur de reporting et de statistiques performant écrit en LINQ pur.

Objectif : Écrire du code asynchrone fluide pour optimiser les performances logicielles et libérer les threads système.

• Appréhender les concepts de tâches, de threads et de concurrence.
• Utiliser les mots-clés fondamentaux async et await pour l'asynchronisme de bout en bout.
• Manipuler les types asynchrones de retour : Task, Task<T>, ValueTask et la gestion d'annulation avec CancellationToken.

Atelier pratique : Création d'un module d'appel asynchrone parallèle pour interroger plusieurs APIs web publiques de météo ou de taux de change simultanément.

Cas métier : Création d'un module d'appel asynchrone parallèle (async/await/Task) pour interroger plusieurs APIs Web publiques simultanément sans bloquer le thread principal.

Compétence acquise : Être capable d'implémenter des processus non bloquants, réactifs et fluides.

Livrable : Client d'intégration API multi-sources ultra-rapide et asynchrone.

Objectif : Sauvegarder l'état d'une application sur le disque et restaurer ses informations.

• Manipuler les flux de données (Streams) et les fichiers avec l'espace de noms System.IO.
• Sérialiser et désérialiser des objets C# en formats JSON à l'aide de la bibliothèque hautement performante System.Text.Json.
• Configurer la sérialisation (sensibilité à la casse, formatage des dates, propriétés ignorées).

Atelier pratique : Réalisation d'une application d'archivage automatique et de sauvegarde d'historique de commandes au format JSON.

Cas métier : Réalisation d'un module d'archivage automatique et de sauvegarde d'historique de commandes au format JSON (System.Text.Json / System.IO).

Compétence acquise : Savoir stocker, transférer et restaurer l'état applicatif dans des formats ouverts et standardisés.

Livrable : Module autonome de persistance de données locales et d'import/export de configuration.

Objectif : Valider la qualité de l'application développée, écrire ses premiers tests unitaires et distribuer le programme.

• Comprendre la pyramide des tests et l'intérêt des tests unitaires automatisés.
• Créer un projet de test avec xUnit et écrire des scénarios de test rigoureux (structure AAA : Arrange, Act, Assert).
• Compiler et publier son application console finale pour différents systèmes d'exploitation (Windows, Linux, macOS).

Atelier pratique : Couverture par tests unitaires de notre moteur de facturation et publication de l'application finale prête pour le déploiement client.

Cas métier : Couverture par tests unitaires automatisés xUnit du moteur de facturation et génération du paquet de distribution final multi-plateforme.

Compétence acquise : Savoir valider, packager et distribuer une solution logicielle .NET propre, documentée et testée.

Livrable : Application .NET d'entreprise finalisée, testée à 100 % et paquet de distribution généré.

Objectif : Réutiliser en autonomie la POO, les interfaces, l'injection de dépendances, LINQ et la gestion des erreurs des journées ESSENTIEL pour construire une application.

• Réactiver les acquis des journées ESSENTIEL : rappel visuel et quiz sur les classes, l'héritage, les interfaces, l'injection de dépendances, les exceptions et LINQ.
• Concevoir le modèle de classes d'une application et ses services, puis interroger les données avec LINQ.

Atelier pratique : Entraînement en binômes : relire le modèle de classes d'un autre binôme et repérer les responsabilités mal réparties, avec correction croisée.

Cas métier : La gestion des commandes (cas fil rouge) - Les participants conçoivent les classes et les interfaces de l'application, branchent les services par injection de dépendances, écrivent les requêtes LINQ de suivi et gèrent les erreurs, puis présentent leur conception au groupe.

Compétence acquise : Savoir concevoir en autonomie une application C# claire et bien structurée.

Livrable : Le projet C# de gestion des commandes, construit avec les modèles des journées ESSENTIEL.

Objectif : Mettre à l'épreuve la persistance, l'asynchrone et les tests unitaires de son application avant de la livrer.

• Retour sur async / await, la sérialisation JSON, les fichiers, les tests unitaires et le packaging vus les jours précédents.
• Rendre l'application fiable : sauvegarde des données, traitements asynchrones et tests automatiques.

Atelier pratique : Exercice guidé : écrire les tests d'une méthode métier, introduire volontairement un bug et vérifier que les tests le détectent.

Cas métier : La livraison de l'application (cas fil rouge) - Chaque participant ajoute la sauvegarde en JSON, rend les traitements longs asynchrones, écrit les tests unitaires et prépare le paquet de livraison, puis le soumet à une revue de code du groupe et du formateur.

Compétence acquise : Savoir livrer une application C# testée et fiable.

Livrable : L'application packagée et sa suite de tests, issues des modèles des journées ESSENTIEL.