language-csharp

name	language-csharp
title	Doctorat — Langage C#
description	Compétence niveau docteur en C#. Couvre .NET CLR, JIT, GC, Span<T>, Memory<T>, ValueTask, async/await, unsafe code, IL emit, Source Generators, AOT, WinForms, WPF, ASP.NET Core, Blazor, Unity, et l'écosystème .NET.
category	research
lang	fr

Doctorat : Langage C#

Présentation

C# (prononcé "C sharp") est un langage de programmation orienté objet, compilé, multi-paradigme, développé par Microsoft sous la direction d'Anders Hejlsberg (2000). Il est le langage principal de la plateforme .NET et du CLR (Common Language Runtime). C# combine la puissance de C++ avec la simplicité de Visual Basic, fonctionnant sur une machine virtuelle garbage-collected (CLR) avec JIT (Just-In-Time). Il est utilisé pour le développement d'applications Windows, web (ASP.NET Core), jeux (Unity), mobile (Xamarin/MAUI), cloud (Azure) et plus.

Histoire et Contexte

• 2000 : Annoncé par Microsoft (PDC 2000) comme langage .NET
• 2002 : C# 1.0 avec .NET Framework 1.0
• 2005 : C# 2.0 — génériques, yield, nullable types
• 2007-2008 : C# 3.0 — LINQ, expression trees, lambdas, extension methods
• 2010-2012 : C# 4.0 — dynamic, covariance/contravariance ; C# 5.0 — async/await
• 2015 : C# 6.0 — null-conditional, string interpolation, nameof
• 2017 : C# 7.0-7.3 — tuples, pattern matching, ref returns, local functions
• 2019 : C# 8.0 — nullable reference types, async streams, default interface methods
• 2020 : C# 9.0 — records, init-only, top-level statements, source generators
• 2021-2022 : C# 10.0-11.0 — global using, file-scoped namespaces, required, ref fields, raw string literals
• 2023-2024 : C# 12.0 — primary constructors, collection expressions, interceptors
• 2024-2025 : C# 13.0 — extension types, ref struct parameters, params collections

Architecture du Langage

• Compilateur Roslyn : Compilateur open-source en C# (auto-hébergé)
• CLR (Common Language Runtime) : Machine virtuelle .NET — exécute IL (Intermediate Language)
• JIT (Just-In-Time) : Compilation IL → code natif (x86, x64, ARM64, WASM)
• AOT : Native AOT (depuis .NET 8) — compilation anticipée en binaire natif
• .NET : Plateforme open-source, cross-platform (Windows, Linux, macOS)
• IL (Intermediate Language) : Bytecode .NET (assembly .dll/.exe)
• Metadata : Informations de type dans l'assembly (réflexion, sérialisation)
• Source Generators : Génération de code source à la compilation (C# 9+)
• Interceptors : Remplacement de code à la compilation (C# 12+)

Système de Types

• Type system unifié : Tout hérite de object (int, string, class, record)
• Value types : struct, enum — allocation sur la stack (ou inline dans les conteneurs)
• Reference types : class, record, interface, delegate — allocation sur le heap managé
• Nullable : int?, string? — valeur + null (Nullable)
• Generics : List, Dictionary<K,V> — génériques réifiés (à la différence de Java)
• Records (C# 9+) : Types immuables avec value equality
• Records structs (C# 10+) : Value types immuables
• Required properties (C# 11+) : Propriétés obligatoires à l'initialisation
• ref struct : Struct sur la stack uniquement (Span, Memory)
• Unions : Discriminated unions limités via records + switch
• Interfaces : Contrats avec implémentations par défaut (C# 8+)
• Delegates : Pointeurs de fonction type-safe (Action, Func, Predicate)
• Pattern matching : Switch expressions, property patterns, list patterns (C# 11)

Compilation et Interprétation

• Roslyn compiler : Compilation C# → IL → CLI assembly
• JIT compilation : RyuJIT (x86/x64/ARM64) — compilation à la volée
• Tiered JIT : Compilation en deux paliers (quick + optimized)
• ReadyToRun : Images pré-compilées pour un démarrage plus rapide
• Native AOT : .NET 8+ — compilation en natif (pas de JIT)
• ILLink : Linker d'IL pour réduire la taille
• Source Generators : Génération de code C# pendant la compilation
• Expression trees : Arbres d'expressions compilables à l'exécution (LINQ providers)
• Reflection.Emit : Génération d'IL à l'exécution
• DLL/Exe : Format PE (Windows) ou ELF (Linux) avec métadonnées CLI

Mémoire et Performances

• Garbage collector : GC générationnel (gen 0, 1, 2), concurrent, mark-compact
• GC modes : Workstation GC, Server GC (multi-threaded), Background GC
• GC Tuning : GCSettings.LatencyMode, GC.Collect(), GC.AddMemoryPressure()
• Large Object Heap (LOH) : Objets >85KB — compaction différée
• Pinned objects : Objets épinglés pour les appels P/Invoke
• Span / Memory (C# 7.2+) : Vues mémoire type-safe sans allocation
• ref struct : Struct sur la stack, pas de boxing, pas de heap
• ValueTask : Task sans allocation pour les résultats synchrones
• stackalloc : Allocation sur la stack
• Unsafe code : Pointeurs, fixed, stackalloc — accès mémoire non managé
• Array pools : System.Buffers.ArrayPool — pooling de tableaux
• String interning : Intern pool pour les chaînes
• Object pooling : Microsoft.Extensions.ObjectPool

Écosystème et Outils

• .NET SDK : dotnet CLI — build, run, test, publish
• Visual Studio : IDE complet (Windows), Rider (cross-platform)
• VS Code : Éditeur avec C# Dev Kit
• NuGet : Gestionnaire de paquets (nuget.org)
• ASP.NET Core : Framework web (MVC, Web API, Razor, Blazor)
• Entity Framework Core : ORM moderne
• WinForms / WPF / MAUI : UI frameworks
• Blazor : Web UI en C# (WebAssembly + Server)
• Unity : Moteur de jeu (C# comme langage de script)
• Xamarin : Mobile (remplacé par MAUI)
• SignalR : WebSocket temps réel
• gRPC : RPC haute performance
• MediatR : CQRS / Mediator pattern
• FluentValidation : Validation
• AutoMapper : Mapping d'objets
• Serilog / NLog : Logging structuré

Concurrence et Parallélisme

• async/await (C# 5+) : Asynchronisme basé sur Task
• Task Parallel Library (TPL) : Task, Task, Parallel.For, Parallel.ForEach
• PLINQ : Parallel LINQ — AsParallel()
• IAsyncEnumerable (C# 8+) : Streams asynchrones (await foreach)
• System.Threading.Channels : Channels producteur/consommateur
• ValueTask : Task sans allocation pour résultats synchrones
• Thread : Threads natifs (System.Threading)
• ThreadPool : Pool de threads managé
• Mutex, SemaphoreSlim, ReaderWriterLockSlim : Synchronisation
• Barrier, CountdownEvent : Primitives de synchronisation
• lock statement : Monitor.Enter/Exit — verrou d'exclusion mutuelle
• Concurrent collections : ConcurrentBag, ConcurrentQueue, ConcurrentDictionary
• SpinLock, SpinWait : Verrous légers en attente active
• Interlocked : Opérations atomiques (Increment, CompareExchange)
• Dataflow : TPL Dataflow — pipeline de blocs de message
• Actor model : Akka.NET, Orleans (Virtual Actors)
• Reactive Extensions (Rx.NET) : Programmation réactive

Patterns Avancés

• DI (Dependency Injection) : Intégré à ASP.NET Core (IServiceProvider)
• Mediator / CQRS : MediatR, Brighter, MassTransit
• Repository / Unit of Work : Couche d'accès aux données
• Specification pattern : Requêtes réutilisables
• Strategy pattern : Algorithmes interchangeables
• Command pattern : Encapsulation d'opérations
• Observer / Events : Events C# natifs (event, delegate)
• Factory / Abstract Factory : Création d'objets
• Builder pattern : Construction fluide (fluent API)
• Proxy pattern : Contrôle d'accès (RealProxy, DispatchProxy)
• Decorator pattern : Enrichissement de fonctionnalités
• Saga / Orchestration : Workflows distribués (MassTransit, NServiceBus)
• Pipeline / Middleware : Chaîne de traitement (ASP.NET Core pipeline)

Optimisation

• Span / Memory : Vues sans allocation sur la mémoire
• ArrayPool : Pool de tableaux pour réduire GC
• Object pooling : Réutilisation d'objets lourds
• Stackalloc : Allocation stack pour les petits buffers
• ref returns : Retour par référence (évite la copie)
• ReadOnlySpan : Vue lecture seule
• Unsafe : Pointer arithmetic pour les boucles chaudes
• SIMD : System.Numerics.Vector, Vector128/256/512 (hardware intrinsics)
• Intrinsics : System.Runtime.Intrinsics (SSE, AVX, ARM NEON)
• ValueTask : Évite l'allocation Task
• struct overloads : Évite le boxing
• IL Emit : Génération de code à l'exécution
• Source Generators : Génération de code à la compilation (remplace la réflexion)
• AOT : Compilation anticipée (pas de JIT, moins de mémoire)
• BenchmarkDotNet : Benchmarking de précision
• Memory diagnostics : dotnet-counters, dotnet-dump, dotnet-gcdump

Interopérabilité

• P/Invoke : Appel de fonctions C non managées (DLL)
• COM Interop : Interaction avec COM (Component Object Model)
• C++/CLI : Interop C++ → .NET (Microsoft only, Windows)
• WinRT : Windows Runtime API
• UnmanagedCallersOnly : C# → C (appel depuis code natif)
• WASM : Blazor WebAssembly — C# dans le navigateur
• gRPC : Interop via protobuf (cross-platform, cross-language)
• REST APIs : ASP.NET Core Web API
• SignalR : WebSocket interop (client JavaScript, .NET)
• Python : Python.NET — interop C# ↔ Python
• Java : IKVM — JVM interop
• JavaScript/TypeScript : Blazor, JSInterop
• Swift/Objective-C : Xamarin/MAUI — iOS/macOS bindings
• FFI : Native library loading (via NativeLibrary)

Applications Industrielles

• Microsoft : Azure, Visual Studio, Office 365 (part), .NET itself
• Stack Overflow : Site web — ASP.NET MVC
• Unity : Jeux vidéo (80%+ des jeux mobiles et indie)
• JetBrains : Rider, ReSharper — applications IDE
• Reddit (ancien) : Stack Exchange-like, ASP.NET
• GoDaddy : Plateforme d'hébergement
• Venmo : Paiement mobile (API)
• Epic Systems : Dossiers médicaux électroniques
• Bank of America : Applications bancaires
• Siemens : Automatisation industrielle
• HP : Logiciels d'impression et gestion
• Unity Technologies : Moteur de jeu en C++ avec scripting C#
• GitHub Desktop : Application Windows (Electron + .NET)
• Azure DevOps : CI/CD et gestion de projet

Sécurité

• Memory safety : GC, bounds checking, nullable reference types
• Nullable Reference Types (C# 8+) : Détection statique des null references
• Unsafe code : unsafe {} — nécessite autorisation (AllowUnsafeBlocks)
• Source Generators : Génération de code type-safe
• Security Transparency : SecurityTransparent, SecurityCritical
• Code Access Security (CAS) : (obsolète) — permissions
• Cryptography : System.Security.Cryptography (AES, RSA, ECDSA, ChaCha20-Poly1305)
• Data Protection : ASP.NET Core Data Protection
• Authentication : ASP.NET Core Identity, OAuth, OpenID Connect
• Authorization : Policies, Roles, Claims
• Anti-forgery : Anti-CSRF tokens intégrés (ASP.NET Core)
• Kestrel : Serveur web sécurisé (TLS 1.3, HTTP/2, HTTP/3)
• Secure string : System.Security.SecureString (pH mémoire)
• Dependency scanning : dotnet list package --vulnerable

Veille Technologique

• dotnet.microsoft.com : Site officiel .NET
• GitHub : dotnet/roslyn, dotnet/runtime, dotnet/aspnetcore
• .NET Blog : devblogs.microsoft.com/dotnet
• Conférences : .NET Conf (annuel), NDC, Build, Ignite
• C# Language Design : github.com/dotnet/csharplang
• YouTube : dotNET, Nick Chapsas, IAmTimCorey
• Reddit : r/csharp, r/dotnet
• Podcasts : .NET Rocks, The Modern .NET Show
• Évolutions clés : AOT (Native), C# 13 extension types, dotNET 9 et 10, Blazor United, MAUI 9