async/await permet un code asynchrone et non-bloquant qui se lit comme du code synchrone. C'est essentiel pour les opérations d'E/S liées (base de données, réseau, accès fichier) — permettant à un programme de gérer d'autres tâches (ou requêtes) pendant qu'il attend des opérations lentes, améliorant la réactivité et la scalabilité.
{
client = HttpClient();
result = client.GetStringAsync(url);
result;
}
data = GetDataAsync();
Une méthode async retourne Task (ou Task<T>), et await suspend la méthode jusqu'à ce que l'opération attendue se termine — sans bloquer le thread. Pendant l'attente, le thread est libéré pour faire autre chose (gérer d'autres requêtes, maintenir l'interface utilisateur réactive). Le code se lit de haut en bas comme du code synchrone malgré sa nature asynchrone.
❌ synchronous I/O — the thread BLOCKS, doing nothing while waiting (wastes resources)
✅ async I/O — the thread is RELEASED during the wait, serving other work
→ A web server using async can handle far more concurrent requests with fewer threads.
// ❌ sequential — total time = sum of both
var a = await GetAAsync();
var b = await GetBAsync();
// ✅ concurrent — start both, then await both (total = max, not sum)
Task<string> taskA = GetAAsync();
Task<string> taskB = GetBAsync();
await Task.WhenAll(taskA, taskB); // run independent operations in parallel
Utilisez Task.WhenAll pour attendre plusieurs opérations indépendantes concurremment — un gain de performance significatif quand elles ne dépendent pas les unes des autres.
✓ Use async "all the way" — async methods called by async methods
✓ Name async methods with the Async suffix (convention)
✗ AVOID async void (except event handlers) — exceptions are unobservable, can crash
✗ AVOID blocking on async (.Result / .Wait()) — can DEADLOCK; await instead
✓ async is for I/O-bound work; for CPU-bound parallelism use Task.Run / Parallel
async/await est une fonctionnalité fondamentale, largement utilisée en C# moderne — essentielle pour construire des applications réactives et scalables, donc la comprendre est important.
Sa valeur principale est d'activer l'E/S asynchrone non-bloquante : pour les opérations d'E/S liées (requêtes base de données, appels HTTP, accès fichier), async/await permet au thread d'être libéré pendant l'attente pour faire autre chose, plutôt que de rester bloqué inactif — ce qui améliore dramatiquement la scalabilité (un serveur web peut gérer beaucoup plus de requêtes concurrentes avec moins de threads) et la réactivité (les interfaces restent réactives pendant les opérations lentes).
Crucial, cela y arrive tout en gardant le code lisible (il se lit comme du code synchrone malgré sa nature asynchrone), en évitant la complexité des callbacks des approches asynchrones plus anciennes.
Comprendre le pattern (méthodes async retournant Task/Task<T>, await pour les attentes non-bloquantes), exécuter des opérations concurremment avec Task.WhenAll (un gain de performance significatif pour les opérations indépendantes), et surtout les pièges (éviter async void en dehors des gestionnaires d'événements — ses exceptions peuvent planter l'app; ne jamais bloquer sur async avec .Result/.Wait() — cela peut causer un deadlock; utiliser async « partout ») est important pour écrire du C# asynchrone correct et performant.
Puisque async/await est omniprésent en C# moderne (ASP.NET Core, EF Core, et la plupart des APIs d'E/S sont async-first), et puisque l'utiliser mal cause de vrais problèmes (deadlocks, plantages, faible scalabilité), le maîtriser — le pattern, la concurrence avec WhenAll, et les pièges critiques — est une connaissance essentielle et fréquemment appliquée pour le développement C# moderne et un sujet d'interview courant et important.