async/await ermöglicht asynchronen, nicht-blockierenden Code, der sich wie synchroner Code liest. Es ist essentiell für I/O-gebundene Arbeit (Datenbank, Netzwerk, Dateizugriff) — ein Programm kann andere Arbeiten (oder Anfragen) erledigen, während es auf langsame Operationen wartet. Dies verbessert Responsivität und Skalierbarkeit.
{
client = HttpClient();
result = client.GetStringAsync(url);
result;
}
data = GetDataAsync();
Eine async-Methode gibt Task (oder Task<T>) zurück, und await unterbricht die Methode, bis die erwartete Operation abgeschlossen ist — ohne den Thread zu blockieren. Während des Wartens wird der Thread freigegeben, um andere Arbeiten zu erledigen (andere Anfragen zu verarbeiten, die UI responsiv zu halten). Der Code liest von oben nach unten wie synchroner Code, obwohl er asynchron ist.
❌ 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
Verwenden Sie Task.WhenAll, um mehrere unabhängige Operationen gleichzeitig zu erwarten — eine erhebliche Beschleunigung, wenn diese nicht voneinander abhängen.
✓ 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 ist eine grundlegende, häufig verwendete Funktion in modernem C# — essentiell für die Erstellung responsiver, skalierbarer Anwendungen, daher ist das Verständnis dafür wichtig.
Sein Kernwert liegt darin, nicht-blockierendes asynchrones I/O zu ermöglichen: Bei I/O-gebundenen Operationen (Datenbankabfragen, HTTP-Aufrufe, Dateizugriff) können Sie mit async/await den Thread während des Wartens freigeben, um andere Arbeiten zu erledigen, anstatt untätig zu blockieren — dies verbessert die Skalierbarkeit dramatisch (ein Webserver kann mit weniger Threads weitaus mehr gleichzeitige Anfragen verarbeiten) und die Responsivität (UIs bleiben während langsamer Operationen responsiv).
Entscheidend ist, dass dies erreicht wird, während der Code lesbar bleibt (er liest sich wie synchroner Code, obwohl er asynchron ist), wodurch die Callback-Komplexität älterer Async-Ansätze vermieden wird.
Das Verständnis des Musters (Async-Methoden geben Task/Task<T> zurück, await für nicht-blockierende Waits), das Ausführen von Operationen gleichzeitig mit Task.WhenAll (ein erheblicher Leistungsgewinn für unabhängige Operationen) und insbesondere die Fallstricke (vermeiden Sie async void außer bei Event Handlern — seine Ausnahmen können die App zum Absturz bringen; blockieren Sie niemals auf Async mit .Result/.Wait() — es kann zu Deadlocks führen; verwenden Sie Async "überall") sind wichtig für das Schreiben von korrektem, performantem asynchronem C#.
Da async/await in modernem C# weit verbreitet ist (ASP.NET Core, EF Core und die meisten I/O-APIs sind Async-first), und da sein Missbrauch zu echten Problemen führt (Deadlocks, Abstürze, schlechte Skalierbarkeit), ist das Beherrschen — des Musters, der Nebenläufigkeit mit WhenAll und der kritischen Fallstricke — essentielles, häufig angewendetes Wissen für die moderne C#-Entwicklung und ein häufiges, wichtiges Interview-Thema.