En 2026, la productivité en C# ne dépend pas uniquement de l’intelligence artificielle. Bien sûr, les LLM et autres assistants peuvent nous aider, mais il existe aussi des bibliothèques maintenues et modernisées, pensées pour .NET 9 et C# 14, qui rendent le code plus clair, plus robuste et surtout plus agréable à écrire et à tester. Ces outils transforment le quotidien du développeur en permettant d’aller plus vite, de coder plus propre, tout en gardant intact le plaisir de programmer.
Aujourd’hui, je voudrais attirer votre attention sur quelques-unes de ces librairies. L’ordre de présentation n’a pas d’importance, la liste n’est pas exhaustive, mais chacune illustre à sa manière comment la communauté C# continue à faire évoluer son écosystème. Moi qui suis adepte du découplage et du MVVM, je commence naturellement par…
MediatR — le CQRS léger et moderne
MediatR est un médiateur simple et non intrusif qui permet de découpler les composants d’une application. Son objectif est d’éviter les dépendances directes entre services. Il est souvent utilisé pour implémenter le pattern CQRS (Command Query Responsibility Segregation), qui sépare les opérations de commande (modification de l’état du système) des requêtes (lecture de l’état). Le code devient ainsi plus lisible et testable.
Contrairement à MVVM, qui organise la logique de présentation, MediatR structure la communication interne de l’application. Les deux approches sont compatibles : un ViewModel peut exposer une commande qui envoie une requête MediatR, et la réponse met à jour l’état de l’écran.
Créé en 2014, MediatR est très actif sur GitHub (LuckyPennySoftware/MediatR), avec plusieurs milliers de stars et de nombreuses adaptations à .NET 9 et C# 14 : records et primary constructors, pipeline behaviors simplifiés, intégration aux minimal APIs, meilleure compatibilité avec les source generators…
Le principe est simple : on définit un record représentant le message, on crée une classe qui fournit la réponse, on enregistre le tout dans le système de DI, et il ne reste plus qu’à appeler await mediator.Send(...). C’est propre, lisible, peu verbeux, et parfaitement aligné avec l’esprit MVVM.
FitR — des tests HTTP modernes et élégants
FitR est un framework de tests HTTP né en 2015 comme projet scientifique, puis adapté à C#. Il permet d’écrire des scénarios lisibles et robustes pour valider des APIs, des webhooks ou des clients HTTP. Sa syntaxe fluide et ses snapshots intégrés simplifient la vie des développeurs.
Le projet est stable, avec une activité modérée sur GitHub (sbfnk/fitR), mais il a été adapté à C# 14 et .NET 9 : lambdas améliorées, interpolated strings pour les snapshots, etc.
Exemple :
await Fit.Http("GET", "/api/users/42")
.ExpectStatus(200)
.ExpectJsonSnapshot("User_42_Snapshot");
Polly — la résilience moderne et composable
Polly est probablement la plus connue de cette sélection. Créée en 2015 et membre de la .NET Foundation, elle compte plus de 14k stars sur GitHub et une documentation très riche. Son objectif est de simplifier la gestion des erreurs transitoires grâce à des stratégies de retry, timeout ou circuit breaker.
https://github.com/App-vNext/Polly
La version 2.x apporte une API pipeline unifiée et une intégration directe dans HttpClient. Exemple :
var pipeline = new ResiliencePipelineBuilder()
.AddRetry(new RetryStrategyOptions { MaxRetryAttempts = 3 })
.AddTimeout(TimeSpan.FromSeconds(2))
.Build();
await pipeline.ExecuteAsync(async ct =>
{
return await httpClient.GetAsync("/api/data", ct);
});
System.CommandLine — le CLI moderne et agréable
System.CommandLine, produit Microsoft lancé en 2019, fournit une API simple et typée pour créer des outils en ligne de commande. Son GitHub (dotnet/command-line-api) est actif et la bibliothèque s’intègre progressivement au SDK .NET.
Elle permet de créer facilement des CLI avec binding direct vers les méthodes C#, aide générée automatiquement et gestion simplifiée des sous-commandes. Exemple :
var nameOption = new Option<string>("--name", "Nom de l'utilisateur");
var cmd = new RootCommand("Demo CLI");
cmd.SetHandler((string name) =>
{
Console.WriteLine($"Bonjour {name} !");
}, nameOption);
await cmd.InvokeAsync(args);
Spectre.Console — le terminal qui donne envie d’être utilisé
Spectre.Console est une boîte à outils moderne pour créer des interfaces terminal riches. Widgets, thèmes personnalisables, rendu rapide : cette bibliothèque rend les CLIs plus lisibles et agréables. Créée en 2020, elle est très active sur GitHub, avec une documentation complète et des releases fréquentes.
https://github.com/spectreconsole/spectre.console
Exemple :
AnsiConsole.Write(
new Panel("[green]Opération réussie[/]")
.Header("Statut")
.BorderColor(Color.Green)
);
FluentValidation — validation déclarative et expressive
FluentValidation est une librairie de validation déclarative pour les objets métier. Créée en 2009, elle possède une communauté large et une intégration officielle à ASP.NET Core. Elle exploite désormais les records et primary constructors de C# 14.
https://github.com/FluentValidation/FluentValidation
Exemple :
public record User(string Name, int Age);
public class UserValidator : AbstractValidator<User>
{
public UserValidator()
{
RuleFor(u => u.Name).NotEmpty();
RuleFor(u => u.Age).InclusiveBetween(18, 99);
}
}
Serilog — logging structuré et puissant
Serilog, lancé en 2013, est un framework de logging structuré largement adopté. Il supporte les interpolated string handlers de C# 14 pour des performances accrues et améliore son intégration avec OpenTelemetry.
https://github.com/serilog/serilog
Exemple :
Log.Information($"User {userId} logged in at {DateTime.UtcNow}");
AutoMapper — mapping automatique et robuste
AutoMapper, créé en 2008, est une librairie de mapping automatique entre objets. Elle réduit le code répétitif et supporte désormais les records et init-only setters de C# 14. Son GitHub (AutoMapper/AutoMapper) est très actif.
Exemple :
var config = new MapperConfiguration(cfg =>
cfg.CreateMap<UserEntity, UserDto>());
var mapper = config.CreateMapper();
UserDto dto = mapper.Map<UserDto>(entity);
Mapster — mapping moderne et performant
Mapster, créé en 2016, est une alternative plus légère et rapide à AutoMapper. Elle exploite les source generators et les primary constructors de C# 14 pour un mapping encore plus efficace.
https://github.com/MapsterMapper/Mapster
Exemple :
UserDto dto = entity.Adapt<UserDto>();
Conclusion
Voilà une belle brochette de librairies, non exhaustive mais représentative, qui montrent qu’il est possible d’améliorer sa productivité en C# sans dépendre uniquement de l’IA. Certaines existent depuis plus de dix ans, d’autres sont plus récentes, mais toutes ont été modernisées pour tirer parti des avancées de C# 14 et .NET 9.
La productivité se construit aussi grâce à ces outils bien pensés, qui permettent de coder plus vite, plus propre et avec plus de plaisir. Alors pourquoi ne pas en essayer un dès cette semaine, l’intégrer dans votre projet et constater par vous-même la différence qu’il peut apporter à votre quotidien de développeur ?
Le futur du C#, ce n’est pas seulement l’IA : c’est aussi une communauté passionnée qui continue à faire évoluer ses librairies pour nous rendre plus efficaces et plus heureux dans notre métier.
Stay Tuned !