async/await muliggør asynkron, ikke-blokerende kode, der læses som synkron kode. Det er essentielt for I/O-bundet arbejde (database, netværk, filacces) — det lader et program håndtere andet arbejde (eller anmodninger) mens det venter på langsomme operationer, hvilket forbedrer responsivitet og skalerbarhed.
{
client = HttpClient();
result = client.GetStringAsync(url);
result;
}
data = GetDataAsync();
En async-metode returnerer Task (eller Task<T>), og await suspenderer metoden, indtil den ventede operation er fuldført — uden at blokere tråden. Under ventetid frigives tråden til at udføre andet arbejde (håndtere andre anmodninger, holde UI responsiv). Koden læses top-til-bund som synkron kode på trods af at være asynkron.
❌ 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
Brug Task.WhenAll til at vente på flere uafhængige operationer samtidigt — en stor hastigheds- forbedring når de ikke afhænger af hinanden.
✓ 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 er en fundamental, meget brugt funktion i moderne C# — essentiel for at bygge responsive, skalerbare applikationer, så forståelse heraf er vigtig.
Dets kerneværdi er at muliggøre ikke-blokerende asynkron I/O: for I/O-bundne operationer (databaseforespørgsler, HTTP-opkald, filacces) lader async/await tråden blive frigivet under ventetiden til at udføre andet arbejde, i stedet for at blokere uvirksomt — hvilket dramatisk forbedrer skalerbarhed (en webserver kan håndtere langt flere samtidige anmodninger med færre tråde) og responsivitet (UIs forbliver responsive under langsomme operationer).
Vigtigst er det, at det opnår dette mens koden forbliver læsbar (den læses som synkron kode på trods af at være asynkron), hvilket undgår callback-kompleksiteten i ældre async-tilgange.
Forståelse af mønstret (async-metoder returnerer Task/Task<T>, await for ikke-blokerende ventning), kørsel af operationer samtidigt med Task.WhenAll (en betydelig performanceforbedring for uafhængige operationer), og især faldgruberne (undgå async void uden for event handlers — dens undtagelser kan få appen til at gå ned; blokér aldrig på asynkron med .Result/.Wait() — det kan deadlocke; brug async "hele vejen") er vigtig for at skrive korrekt, performant asynkron C#.
Da async/await er allestedsnærværende i moderne C# (ASP.NET Core, EF Core, og de fleste I/O-API'er er async-first), og da misbrug heraf forårsager rigtige problemer (deadlocks, crashes, dårlig skalerbarhed), er beherskelse heraf — mønstret, samtidighed med WhenAll, og de kritiske faldgruber — essentiel, hyppigt anvendt viden for moderne C#-udvikling og et almindeligt, vigtigt interviewemne.