C# .NET - Développement d'applications

C#, .NET 9 et l'écosystème Microsoft : syntaxe, POO, LINQ, tests et accès aux données

Formation créée le 02/04/2026.
Version du programme : 3

Type de formation

Présentiel

Durée de formation

35 heures (5 jours)
Cette formation est gratuite.
S'inscrire
Cette formation est gratuite.
S'inscrire
Cette formation est gratuite.
S'inscrire

C# .NET - Développement d'applications

C#, .NET 9 et l'écosystème Microsoft : syntaxe, POO, LINQ, tests et accès aux données


Vous maîtrisez un autre langage de programmation et souhaitez développer en C# sur l'écosystème .NET : cette formation vous donne les bases solides du langage, les principes de la programmation orientée objet, les outils de l'environnement Microsoft et les bonnes pratiques pour produire un code professionnel, testé et maintenable.

Objectifs de la formation

  • Comprendre l'architecture de la plateforme .NET et le rôle du CLR
  • Maîtriser la syntaxe C# et les types fondamentaux du langage
  • Mettre en oeuvre la programmation orientée objet : classes, héritage, interfaces, polymorphisme
  • Utiliser les collections, LINQ et la gestion des exceptions
  • Développer des applications asynchrones avec async/await et les Tasks
  • Accéder à une base de données avec Entity Framework Core
  • Ecrire et exécuter des tests unitaires avec xUnit
  • Organiser et déployer un projet .NET avec Visual Studio et la CLI .NET

Profil des bénéficiaires

Pour qui
  • Développeurs maîtrisant un autre langage de programmation (Java, Python, C++, PHP ou autre) souhaitant acquérir une maîtrise opérationnelle de C# et de l'écosystème .NET pour développer des applications professionnelles.
Prérequis
  • Expérience de développement logiciel dans au moins un langage de programmation orienté objet.
  • Connaissances de base en algorithmique (variables, boucles, fonctions).
  • Aucune connaissance de C# ou de .NET n'est requise.

Contenu de la formation

L'écosystème .NET et l'environnement de développement
  • La plateforme .NET : historique, .NET Framework vs .NET Core vs .NET 5+ -- comprendre la convergence vers .NET 9
  • Le CLR (Common Language Runtime) : compilation, JIT, gestion de la mémoire et garbage collector
  • Les assemblies et le déploiement : FDD (Framework-Dependent Deployment) vs SCD (Self-Contained Deployment)
  • NuGet : gestionnaire de paquets, ajout de dépendances, fichier .csproj
  • L'environnement de développement : Visual Studio 2022 (IDE complet) et VS Code avec l'extension C# -- cas d'usage de chacun
  • La CLI .NET : commandes essentielles (dotnet new, dotnet build, dotnet run, dotnet test)
  • Structure d'un projet .NET : solution, projets, namespaces, fichiers .cs
Syntaxe C# et types fondamentaux
  • Syntaxe de base : instructions, blocs, commentaires, conventions de nommage C# (PascalCase, camelCase)
  • Types valeur et types référence : sémantique, copie, passage de paramètres et implications mémoire
  • Types primitifs : int, long, double, decimal, bool, char, string -- spécificités C# pour les développeurs venant d'autres langages
  • var et les types implicites : inférence de type, quand l'utiliser
  • Nullable types : int?, string? -- gestion de la nullité, opérateur ??, ?.
  • Conversions : implicites, explicites (cast), Convert, Parse, TryParse
  • Strings en C# : immuabilité, interpolation ($""), verbatim (@""), StringBuilder pour les concaténations répétées
  • Tableaux et types de base des collections : Array, List<T>, Dictionary<TKey,TValue>
Structures de contrôle et fonctions
  • Structures de contrôle : if/else, switch expressions (syntaxe moderne C# 8+), boucles (for, foreach, while, do-while)
  • Pattern matching : is, switch avec patterns (type pattern, property pattern, positional pattern)
  • Méthodes : signature, paramètres, valeurs de retour, passage par valeur vs par référence (ref, out, in)
  • Paramètres optionnels et arguments nommés
  • Méthodes d'extension : principe et cas d'usage pratiques
  • Tuples et déconstruction : (int x, int y), ValueTuple, déconstruction en variables
  • Expressions régulières en C# : Regex, cas d'usage courants (validation, extraction)
Classes, objets et encapsulation
  • Classes et objets : définition, instanciation, constructeurs
  • Propriétés : getters, setters, auto-properties, propriétés en lecture seule (init)
  • Modificateurs d'accès : public, private, protected, internal, protected internal
  • Membres statiques : champs et méthodes statiques, classe statique
  • Records (C# 9+) : types de référence avec égalité par valeur, with expressions, cas d'usage pour les DTOs
  • Structs : différences avec les classes, quand les utiliser
  • Champs en lecture seule (readonly) et constantes (const)
Héritage, interfaces et polymorphisme
  • Héritage : syntaxe C#, appel au constructeur parent (base), override et virtual
  • Classes abstraites : abstract class, méthodes abstraites, différences avec les interfaces
  • Interfaces : définition, implémentation multiple, interfaces avec implémentation par défaut (C# 8+)
  • Polymorphisme : is et as, pattern matching sur les types
  • Sealed classes et méthodes : empêcher l'héritage, cas d'usage
  • Génériques : classes et méthodes génériques, contraintes (where T : class, where T : new())
  • Covariance et contravariance : IEnumerable<out T>, IComparable<in T> -- principes pratiques pour comprendre les collections
Délégués, événements et expressions lambda
  • Délégués : définition, instanciation, multicast delegates
  • Func<T>, Action<T>, Predicate<T> : les délégués génériques prédéfinis
  • Expressions lambda : syntaxe, closures, captures de variables
  • Événements : event, EventHandler, pattern publisher/subscriber
  • Expressions lambda avancées : expression trees, cas d'usage dans LINQ et Entity Framework
Collections et types génériques
  • Les collections .NET : List<T>, Dictionary<TKey,TValue>, HashSet<T>, Queue<T>, Stack<T>
  • Collections immuables : ImmutableList<T>, ImmutableDictionary<TKey,TValue> (System.Collections.Immutable)
  • IEnumerable<T> et IQueryable<T> : différences fondamentales, lazy evaluation
  • Ouverture performance : Span<T> et Memory<T>, manipulation de données sans allocation -- présentation des cas d'usage, approfondissement en formation avancée
  • Comparateurs personnalisés : IComparer<T>, IEqualityComparer<T>
LINQ (Language Integrated Query)
  • Principes de LINQ : requêtes intégrées au langage, deferred execution
  • Syntaxe de requête vs syntaxe de méthode (fluent) : équivalences, quand utiliser laquelle
  • Opérateurs essentiels : Where, Select, OrderBy, GroupBy, Join, Distinct, Take, Skip
  • Opérateurs d'agrégation : Count, Sum, Average, Min, Max
  • Any, All, First, FirstOrDefault, Single, SingleOrDefault : sémantiques et différences importantes
  • SelectMany : aplatissement de collections imbriquées
  • LINQ et les performances : attention aux N+1 avec IQueryable, matérialisation avec ToList() et ToArray()
Gestion des exceptions et des ressources
  • Exceptions en C# : hiérarchie, Exception, exceptions système courantes et bonnes pratiques de création d'exceptions métier
  • try/catch/finally : bonnes pratiques, ne pas avaler les exceptions silencieusement
  • Exceptions personnalisées : créer ses propres types d'exception, propriétés additionnelles
  • Filtres d'exception : when
  • IDisposable et le pattern Dispose : libération des ressources non managées
  • L'instruction using : syntaxe classique et déclaration using (C# 8+)
  • Journalisation : Microsoft.Extensions.Logging, niveaux de log, ILogger<T>
Programmation asynchrone avec async/await
  • Le modèle asynchrone .NET : Thread, ThreadPool, Task -- évolution historique et modèle actuel
  • Task et Task<T> : création, attente, continuation
  • async/await : syntaxe, règles fondamentales (ne pas bloquer avec .Result ou .Wait())
  • Méthodes de Task : Task.WhenAll(), Task.WhenAny(), Task.Run()
  • CancellationToken : annulation coopérative des opérations longues
  • ConfigureAwait(false) : principe et cas d'usage dans le développement de bibliothèques réutilisables -- présentation
  • Pièges courants : deadlocks, async void, await dans les boucles
Accès aux données avec Entity Framework Core
  • Entity Framework Core : ORM, DbContext, DbSet<T>, migrations
  • Code First : définir le modèle, configurer les relations (Data Annotations vs Fluent API)
  • Relations : one-to-many, many-to-many, one-to-one -- configuration et comportement en cascade
  • Migrations : Add-Migration, Update-Database, gestion du schéma de base de données
  • Requêtes avec EF Core : LINQ sur DbSet, Include() pour le chargement des relations, AsNoTracking()
  • Opérations CRUD : Add, Update, Remove, SaveChangesAsync()
  • Transactions et gestion de la concurrence
Entrées/sorties et sérialisation
  • System.IO : File, Directory, Path, FileStream -- lecture et écriture de fichiers
  • StreamReader et StreamWriter : lecture/écriture de texte avec encodage
  • Sérialisation JSON avec System.Text.Json : JsonSerializer, options de configuration, attributs [JsonPropertyName]
  • Sérialisation JSON avancée : converters personnalisés, JsonDocument pour le parsing léger
  • HttpClient : appels HTTP, gestion des headers, désérialisation des réponses -- IHttpClientFactory pour l'injection
Tests unitaires avec xUnit
  • Pourquoi tester : valeur des tests unitaires dans un projet .NET, intégration dans la CI/CD
  • xUnit : framework de test très répandu dans l'écosystème .NET, comparaison avec NUnit et MSTest
  • Ecrire un test : [Fact], [Theory], [InlineData], Assert et ses méthodes
  • Organisation des tests : structure du projet de test, conventions de nommage
  • Mocking avec Moq : créer des doublures, configurer les comportements, vérifier les appels
  • Tester du code asynchrone : async Task dans les tests
  • Couverture de code : analyse avec Coverlet et rapport dans Visual Studio
Introduction à ASP.NET Core et aux API REST
  • ASP.NET Core : architecture, pipeline de middleware, Program.cs avec les Minimal APIs (.NET 6+)
  • Injection de dépendances native .NET : IServiceCollection, AddSingleton/Scoped/Transient, IServiceProvider
  • Minimal APIs : définir des routes, paramètres, réponses typées (Results.Ok, Results.NotFound...)
  • Controllers et attributs : [ApiController], [HttpGet], [HttpPost], routing par attributs
  • Validation avec Data Annotations et ModelState
  • Configuration : appsettings.json, variables d'environnement, IConfiguration
  • Swagger/OpenAPI : documentation automatique avec Swashbuckle
Architecture, bonnes pratiques et déploiement
  • Organisation d'une solution .NET : séparation des responsabilités, principes SOLID appliqués -- ouverture vers la Clean Architecture
  • Gestion de la configuration et des secrets : User Secrets en développement, variables d'environnement en production
  • Publication et déploiement : dotnet publish, options de publication (FDD, SCD)
  • Bonnes pratiques de code C# : .editorconfig et analyse statique avec les Roslyn analyzers intégrés à Visual Studio
  • Ouverture : Docker et AOT (Ahead-of-Time compilation) -- présentation des cas d'usage, sans mise en oeuvre dans ce parcours
  • Plan d'action individuel : chaque participant identifie les trois sujets à approfondir ou à appliquer immédiatement

Équipe pédagogique

Formateur expert en développement C# et écosystème .NET, intervenant en environnement professionnel sur des projets d'application Microsoft.

Suivi de l'exécution et évaluation des résultats

  • Auto-positionnement en amont (questionnaire)
  • Evaluation formative pendant la formation (travaux pratiques)
  • Evaluation des acquis en fin de formation (quiz)
  • Evaluation de satisfaction à chaud