async/await möjliggör asynkron, icke-blockerande kod som läses som synkron kod. Det är väsentligt för I/O-bunden arbete (databas, nätverk, filåtkomst) — låter ett program hantera annat arbete (eller förfrågningar) medan långsamma operationer väntas på, vilket förbättrar responsivitet och skalbarhet.
{
client = HttpClient();
result = client.GetStringAsync(url);
result;
}
data = GetDataAsync();
En async-metod returnerar Task (eller Task<T>), och await suspenderar metoden tills den väntade operationen är slutförd — utan att blockera tråden. Under väntan är tråden fri att göra annat arbete (hantera andra förfrågningar, hålla användargränssnittet responsivt). Koden läses uppifrån och ned som synkron kod trots att den är 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
Använd Task.WhenAll för att vänta på flera oberoende operationer samtidigt — en stor prestandaökning när de inte är beroende av varandra.
✓ 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 är en grundläggande, mycket använd funktion i modern C# — väsentlig för att bygga responsiva, skalbara program, så att förstå den är viktigt.
Önvärdet ligger i möjligheten att möjliggöra icke-blockerande asynkron I/O: för I/O-bundna operationer (databasfrågor, HTTP-anrop, filåtkomst) låter async/await tråden frigöras under väntan för att göra annat arbete istället för att blockera inaktiv — vilket dramatiskt förbättrar skalbarhet (en webbserver kan hantera mycket mer samtidiga förfrågningar med färre trådar) och responsivitet (användargränssnitt förblir responsiva under långsamma operationer).
Viktigt är att det uppnår detta medan koden förblir läsbar (den läses som synkron kod trots att den är asynkron), vilket undviker callback-komplexiteten i äldre asynkrona metoder.
Att förstå mönstret (asynkrona metoder som returnerar Task/Task<T>, await för icke-blockerande väntanden), köra operationer samtidigt med Task.WhenAll (en betydande prestandavinst för oberoende operationer) och särskilt fallgroparna (undvik async void utanför händelsehanterare — dess undantag kan krascha appen; blockera aldrig på asynkron med .Result/.Wait() — det kan döda; använd asynkron