Asynchrone programmeerscenario's
Als u I/O-gebonden behoeften hebt (zoals het aanvragen van gegevens vanuit een netwerk, het openen van een database of het lezen en schrijven naar een bestandssysteem), wilt u asynchrone programmering gebruiken. U kunt ook CPU-gebonden code hebben, zoals het uitvoeren van een dure berekening, wat ook een goed scenario is voor het schrijven van asynchrone code.
C# heeft een asynchroon programmeermodel op taalniveau, waarmee u eenvoudig asynchrone code kunt schrijven zonder dat u callbacks hoeft te gebruiken of aan een bibliotheek moet voldoen die asynchroon ondersteunt. Het volgt wat het op taken gebaseerde Asynchrone patroon (TAP) wordt genoemd.
Overzicht van het asynchrone model
De kern van asynchrone programmering is de Task en Task<T> objecten, die asynchrone bewerkingen modelleren. Ze worden ondersteund door de async trefwoorden en await trefwoorden. Het model is in de meeste gevallen redelijk eenvoudig:
- Voor I/O-gebonden code wacht u op een bewerking die een
TaskofTask<T>binnen eenasyncmethode retourneert. - Voor CPU-gebonden code wacht u op een bewerking die is gestart op een achtergrondthread met de Task.Run methode.
Het await trefwoord is waar de magie plaatsvindt. Het geeft de controle over de aanroeper van de methode die is uitgevoerd awaiten het maakt het uiteindelijk mogelijk dat een gebruikersinterface reageert of dat een service elastisch is. Hoewel er manieren zijn om asynchrone code te benaderen dan async en await, is dit artikel gericht op de constructies op taalniveau.
Notitie
In sommige van de volgende voorbeeldenklasse System.Net.Http.HttpClient wordt gebruikt om bepaalde gegevens van een webservice te downloaden.
Het s_httpClient object dat in deze voorbeelden wordt gebruikt, is een statisch veld van Program klasse (controleer het volledige voorbeeld):
private static readonly HttpClient s_httpClient = new();
I/O-gebonden voorbeeld: Gegevens downloaden van een webservice
Mogelijk moet u bepaalde gegevens downloaden uit een webservice wanneer een knop wordt ingedrukt, maar de UI-thread niet wilt blokkeren. Dit kan als volgt worden bereikt:
s_downloadButton.Clicked += async (o, e) =>
{
// This line will yield control to the UI as the request
// from the web service is happening.
//
// The UI thread is now free to perform other work.
var stringData = await s_httpClient.GetStringAsync(URL);
DoSomethingWithData(stringData);
};
Met de code wordt de intentie (het downloaden van gegevens asynchroon) weergegeven zonder dat er sprake is van interactie met Task objecten.
CPU-gebonden voorbeeld: Een berekening uitvoeren voor een game
Stel dat u een mobiel spel schrijft waarbij het drukken op een knop schade kan toebrengen aan veel vijanden op het scherm. Het uitvoeren van de schadeberekening kan duur zijn en als u dit doet op de UI-thread, lijkt het spel te onderbreken terwijl de berekening wordt uitgevoerd!
De beste manier om dit te doen, is om een achtergrondthread te starten, die het werk doet met behulp Task.Runvan , en het resultaat ervan te wachten met behulp van await. Hierdoor kan de gebruikersinterface zich soepel voelen terwijl het werk wordt uitgevoerd.
static DamageResult CalculateDamageDone()
{
return new DamageResult()
{
// Code omitted:
//
// Does an expensive calculation and returns
// the result of that calculation.
};
}
s_calculateButton.Clicked += async (o, e) =>
{
// This line will yield control to the UI while CalculateDamageDone()
// performs its work. The UI thread is free to perform other work.
var damageResult = await Task.Run(() => CalculateDamageDone());
DisplayDamage(damageResult);
};
Met deze code wordt duidelijk de intentie van de klikgebeurtenis van de knop weergegeven. Hiervoor hoeft geen achtergrondthread handmatig te worden beheerd. Dit gebeurt op een niet-blokkerende manier.
Wat gebeurt er onder de dekkingen?
Aan de C#-kant van dingen transformeert de compiler uw code in een statusmachine die dingen bijhoudt, zoals het genereren van uitvoering wanneer een await wordt bereikt en de uitvoering hervat wanneer een achtergrondtaak is voltooid.
Voor de theoretisch geneigde is dit een implementatie van het Promise Model of asynchrony.
Belangrijke onderdelen die u moet begrijpen
- Asynchrone code kan worden gebruikt voor zowel I/O-gebonden als CPU-gebonden code, maar anders voor elk scenario.
- Asynchrone code maakt
Task<T>gebruik van enTask, die constructies zijn die worden gebruikt om werk op de achtergrond te modelleren. - Met
asynchet trefwoord wordt een methode omgezet in een asynchrone methode, waarmee u het trefwoord in deawaithoofdtekst kunt gebruiken. - Wanneer het
awaittrefwoord wordt toegepast, wordt de aanroepmethode onderbroken en wordt de besturingselement teruggezet naar de aanroeper totdat de wachtende taak is voltooid. awaitkan alleen worden gebruikt binnen een asynchrone methode.
CPU-gebonden en I/O-gebonden werk herkennen
De eerste twee voorbeelden van deze handleiding hebben laten zien hoe u Iawait/O-gebonden en CPU-gebonden werk kunt gebruikenasync. Het is belangrijk dat u kunt identificeren wanneer een taak die u moet uitvoeren I/O-gebonden of CPU-gebonden is, omdat deze de prestaties van uw code aanzienlijk kan beïnvloeden en mogelijk kan leiden tot verkeerd gebruik van bepaalde constructies.
Hier volgen twee vragen die u moet stellen voordat u code schrijft:
Wacht uw code op iets, zoals gegevens uit een database?
Als uw antwoord ja is, is uw werk I/O-gebonden.
Voert uw code een dure berekening uit?
Als u ja hebt beantwoord, is uw werk CPU-gebonden.
Als het werk dat u hebt I/O-gebonden is, gebruikt async u en await zonder Task.Run. Gebruik de taakparallelbibliotheek niet .
Als het werk dat u hebt, afhankelijk is van de CPU en u wilt reageren, gebruiken async en await, maar het werk op een andere thread afzetten met Task.Run. Als het werk geschikt is voor gelijktijdigheid en parallelle uitvoering, kunt u ook overwegen om de taakparallelbibliotheek te gebruiken.
Daarnaast moet u altijd de uitvoering van uw code meten. U kunt zich bijvoorbeeld in een situatie bevinden waarin uw CPU-gebonden werk niet kostbaar genoeg is vergeleken met de overhead van contextswitches wanneer multithreading wordt uitgevoerd. Elke keuze heeft zijn compromis en u moet de juiste afweging voor uw situatie kiezen.
Meer voorbeelden
In de volgende voorbeelden ziet u verschillende manieren waarop u asynchrone code kunt schrijven in C#. Ze hebben betrekking op een aantal verschillende scenario's die u kunt tegenkomen.
Gegevens extraheren uit een netwerk
Met dit codefragment wordt de HTML uit de opgegeven URL gedownload en wordt het aantal keren geteld dat de tekenreeks .NET voorkomt in de HTML. Er wordt gebruikgemaakt van ASP.NET voor het definiëren van een web-API-controllermethode, waarmee deze taak wordt uitgevoerd en het getal wordt geretourneerd.
Notitie
Als u van plan bent HTML-parsering uit te voeren in productiecode, gebruikt u geen reguliere expressies. Gebruik in plaats daarvan een parseerbibliotheek.
[HttpGet, Route("DotNetCount")]
static public async Task<int> GetDotNetCount(string URL)
{
// Suspends GetDotNetCount() to allow the caller (the web server)
// to accept another request, rather than blocking on this one.
var html = await s_httpClient.GetStringAsync(URL);
return Regex.Matches(html, @"\.NET").Count;
}
Dit is hetzelfde scenario dat is geschreven voor een Universele Windows-app, waarmee dezelfde taak wordt uitgevoerd wanneer op een knop wordt gedrukt:
private readonly HttpClient _httpClient = new HttpClient();
private async void OnSeeTheDotNetsButtonClick(object sender, RoutedEventArgs e)
{
// Capture the task handle here so we can await the background task later.
var getDotNetFoundationHtmlTask = _httpClient.GetStringAsync("https://dotnetfoundation.org");
// Any other work on the UI thread can be done here, such as enabling a Progress Bar.
// This is important to do here, before the "await" call, so that the user
// sees the progress bar before execution of this method is yielded.
NetworkProgressBar.IsEnabled = true;
NetworkProgressBar.Visibility = Visibility.Visible;
// The await operator suspends OnSeeTheDotNetsButtonClick(), returning control to its caller.
// This is what allows the app to be responsive and not block the UI thread.
var html = await getDotNetFoundationHtmlTask;
int count = Regex.Matches(html, @"\.NET").Count;
DotNetCountLabel.Text = $"Number of .NETs on dotnetfoundation.org: {count}";
NetworkProgressBar.IsEnabled = false;
NetworkProgressBar.Visibility = Visibility.Collapsed;
}
Wacht totdat meerdere taken zijn voltooid
Het kan zijn dat u zich in een situatie bevindt waarin u meerdere gegevens tegelijk moet ophalen. De Task API bevat twee methoden Task.WhenAll en Task.WhenAny, waarmee u asynchrone code kunt schrijven waarmee een niet-blokkerende wachttijd op meerdere achtergrondtaken wordt uitgevoerd.
In dit voorbeeld ziet u hoe u gegevens voor een set userIds kunt ophalenUser.
private static async Task<User> GetUserAsync(int userId)
{
// Code omitted:
//
// Given a user Id {userId}, retrieves a User object corresponding
// to the entry in the database with {userId} as its Id.
return await Task.FromResult(new User() { id = userId });
}
private static async Task<IEnumerable<User>> GetUsersAsync(IEnumerable<int> userIds)
{
var getUserTasks = new List<Task<User>>();
foreach (int userId in userIds)
{
getUserTasks.Add(GetUserAsync(userId));
}
return await Task.WhenAll(getUserTasks);
}
Hier volgt een andere manier om dit beknopter te schrijven met behulp van LINQ:
private static async Task<User[]> GetUsersAsyncByLINQ(IEnumerable<int> userIds)
{
var getUserTasks = userIds.Select(id => GetUserAsync(id)).ToArray();
return await Task.WhenAll(getUserTasks);
}
Hoewel het minder code is, moet u voorzichtig zijn bij het combineren van LINQ met asynchrone code. Omdat LINQ gebruikmaakt van uitgestelde (luie) uitvoering, worden asynchrone aanroepen niet onmiddellijk uitgevoerd zoals in een foreach lus, tenzij u de gegenereerde reeks dwingt om te herhalen met een aanroep naar .ToList() of .ToArray(). In het bovenstaande voorbeeld wordt Enumerable.ToArray de query gretig uitgevoerd en worden de resultaten opgeslagen in een matrix. Hierdoor wordt de code id => GetUserAsync(id) gedwongen om de taak uit te voeren en te starten.
Belangrijke informatie en advies
Bij asynchroon programmeren zijn er enkele details waarmee u rekening moet houden dat onverwacht gedrag kan voorkomen.
asyncmethoden moeten beschikken over eenawaittrefwoord in hun lichaam of ze zullen nooit opleveren!Dit is belangrijk om rekening mee te houden. Als
awaitdeze niet wordt gebruikt in de hoofdtekst van eenasyncmethode, genereert de C#-compiler een waarschuwing, maar de code compileert en wordt uitgevoerd alsof het een normale methode is. Dit is ongelooflijk inefficiënt, omdat de statusmachine die door de C#-compiler voor de asynchrone methode wordt gegenereerd, niets doet.Voeg 'Async' toe als het achtervoegsel van elke asynchrone methodenaam die u schrijft.
Dit is de conventie die in .NET wordt gebruikt om synchrone en asynchrone methoden gemakkelijker te onderscheiden. Bepaalde methoden die niet expliciet worden aangeroepen door uw code (zoals gebeurtenis-handlers of methoden voor webcontrollers) zijn niet noodzakelijkerwijs van toepassing. Omdat ze niet expliciet worden aangeroepen door uw code, is het niet zo belangrijk om expliciet te zijn over hun naamgeving.
async voidmag alleen worden gebruikt voor gebeurtenis-handlers.async voidis de enige manier om asynchrone gebeurtenis-handlers te laten werken omdat gebeurtenissen geen retourtypen hebben (dus niet kunnen worden gebruikt enTaskTask<T>). Elk ander gebruik vanasync voidvolgt het TAP-model niet en kan lastig zijn om te gebruiken, zoals:- Uitzonderingen die in een
async voidmethode worden gegenereerd, kunnen niet buiten die methode worden gevangen. async voidmethoden zijn moeilijk te testen.async voidmethoden kunnen slechte bijwerkingen veroorzaken als de aanroeper niet verwacht dat ze asynchroon zijn.
- Uitzonderingen die in een
Zorgvuldig lezen bij het gebruik van asynchrone lambdas in LINQ-expressies
Lambda-expressies in LINQ gebruiken de uitgestelde uitvoering, wat betekent dat code uiteindelijk wordt uitgevoerd op een moment dat u dit niet verwacht. De introductie van blokkerende taken kan er eenvoudig toe leiden dat er een impasse ontstaat als deze niet correct is geschreven. Daarnaast kan het nesten van asynchrone code, zoals dit, het lastiger maken om te redeneren over de uitvoering van de code. Async en LINQ zijn krachtig, maar moeten zo zorgvuldig en duidelijk mogelijk samen worden gebruikt.
Code schrijven die taken op een niet-blokkerende manier wacht
Het blokkeren van de huidige thread als een manier om te wachten tot een
Taskbewerking is voltooid, kan leiden tot impasses en geblokkeerde contextthreads en kan complexere foutafhandeling vereisen. De volgende tabel bevat richtlijnen voor het omgaan met wachten op taken op een niet-blokkerende manier:Gebruikt u... In plaats van dit... Als u dit wilt doen... awaitTask.WaitofTask.ResultHet resultaat van een achtergrondtaak ophalen await Task.WhenAnyTask.WaitAnyWachten tot een taak is voltooid await Task.WhenAllTask.WaitAllWachten tot alle taken zijn voltooid await Task.DelayThread.SleepWachten op een bepaalde periode Overweeg waar mogelijk gebruik te maken
ValueTaskHet retourneren van een
Taskobject vanuit asynchrone methoden kan leiden tot prestatieknelpunten in bepaalde paden.Taskis een verwijzingstype, dus als u dit gebruikt, betekent dit dat u een object toewijst. In gevallen waarin een methode die is gedeclareerd met de modifier een resultaat in deasynccache retourneert of synchroon wordt voltooid, kunnen de extra toewijzingen een aanzienlijke tijdskosten worden in prestatiekritieke secties van code. Het kan kostbaar worden als deze toewijzingen voorkomen in strakke lussen. Zie gegeneraliseerde asynchrone retourtypen voor meer informatie.Overweeg het gebruik van
ConfigureAwait(false)Een veelvoorkomende vraag is: 'Wanneer moet ik de Task.ConfigureAwait(Boolean) methode gebruiken?'. Met de methode kan een
Taskinstantie de wachter configureren. Dit is een belangrijke overweging en het onjuist instellen ervan kan mogelijk gevolgen hebben voor de prestaties en zelfs impasses. Zie de veelgestelde vragen over ConfigureAwait voor meer informatieConfigureAwait.Minder stateful code schrijven
Niet afhankelijk van de status van globale objecten of de uitvoering van bepaalde methoden. In plaats daarvan is dit alleen afhankelijk van de retourwaarden van methoden. Waarom?
- Code is gemakkelijker te redeneren.
- Code is eenvoudiger te testen.
- Het combineren van asynchrone en synchrone code is veel eenvoudiger.
- Raceomstandigheden kunnen doorgaans helemaal worden vermeden.
- Afhankelijk van retourwaarden is het coördineren van asynchrone code eenvoudig.
- (Bonus) het werkt heel goed met afhankelijkheidsinjectie.
Een aanbevolen doel is om volledige of bijna volledige referentiële transparantie in uw code te bereiken. Als u dit doet, resulteert dit in een voorspelbare, testbare en onderhoudbare codebase.
Volledig voorbeeld
De volgende code is de volledige tekst van het Program.cs-bestand voor het voorbeeld.
using System.Text.RegularExpressions;
using System.Windows;
using Microsoft.AspNetCore.Mvc;
class Button
{
public Func<object, object, Task>? Clicked
{
get;
internal set;
}
}
class DamageResult
{
public int Damage
{
get { return 0; }
}
}
class User
{
public bool isEnabled
{
get;
set;
}
public int id
{
get;
set;
}
}
public class Program
{
private static readonly Button s_downloadButton = new();
private static readonly Button s_calculateButton = new();
private static readonly HttpClient s_httpClient = new();
private static readonly IEnumerable<string> s_urlList = new string[]
{
"https://learn.microsoft.com",
"https://learn.microsoft.com/aspnet/core",
"https://learn.microsoft.com/azure",
"https://learn.microsoft.com/azure/devops",
"https://learn.microsoft.com/dotnet",
"https://learn.microsoft.com/dotnet/desktop/wpf/get-started/create-app-visual-studio",
"https://learn.microsoft.com/education",
"https://learn.microsoft.com/shows/net-core-101/what-is-net",
"https://learn.microsoft.com/enterprise-mobility-security",
"https://learn.microsoft.com/gaming",
"https://learn.microsoft.com/graph",
"https://learn.microsoft.com/microsoft-365",
"https://learn.microsoft.com/office",
"https://learn.microsoft.com/powershell",
"https://learn.microsoft.com/sql",
"https://learn.microsoft.com/surface",
"https://dotnetfoundation.org",
"https://learn.microsoft.com/visualstudio",
"https://learn.microsoft.com/windows",
"https://learn.microsoft.com/maui"
};
private static void Calculate()
{
// <PerformGameCalculation>
static DamageResult CalculateDamageDone()
{
return new DamageResult()
{
// Code omitted:
//
// Does an expensive calculation and returns
// the result of that calculation.
};
}
s_calculateButton.Clicked += async (o, e) =>
{
// This line will yield control to the UI while CalculateDamageDone()
// performs its work. The UI thread is free to perform other work.
var damageResult = await Task.Run(() => CalculateDamageDone());
DisplayDamage(damageResult);
};
// </PerformGameCalculation>
}
private static void DisplayDamage(DamageResult damage)
{
Console.WriteLine(damage.Damage);
}
private static void Download(string URL)
{
// <UnblockingDownload>
s_downloadButton.Clicked += async (o, e) =>
{
// This line will yield control to the UI as the request
// from the web service is happening.
//
// The UI thread is now free to perform other work.
var stringData = await s_httpClient.GetStringAsync(URL);
DoSomethingWithData(stringData);
};
// </UnblockingDownload>
}
private static void DoSomethingWithData(object stringData)
{
Console.WriteLine("Displaying data: ", stringData);
}
// <GetUsersForDataset>
private static async Task<User> GetUserAsync(int userId)
{
// Code omitted:
//
// Given a user Id {userId}, retrieves a User object corresponding
// to the entry in the database with {userId} as its Id.
return await Task.FromResult(new User() { id = userId });
}
private static async Task<IEnumerable<User>> GetUsersAsync(IEnumerable<int> userIds)
{
var getUserTasks = new List<Task<User>>();
foreach (int userId in userIds)
{
getUserTasks.Add(GetUserAsync(userId));
}
return await Task.WhenAll(getUserTasks);
}
// </GetUsersForDataset>
// <GetUsersForDatasetByLINQ>
private static async Task<User[]> GetUsersAsyncByLINQ(IEnumerable<int> userIds)
{
var getUserTasks = userIds.Select(id => GetUserAsync(id)).ToArray();
return await Task.WhenAll(getUserTasks);
}
// </GetUsersForDatasetByLINQ>
// <ExtractDataFromNetwork>
[HttpGet, Route("DotNetCount")]
static public async Task<int> GetDotNetCount(string URL)
{
// Suspends GetDotNetCount() to allow the caller (the web server)
// to accept another request, rather than blocking on this one.
var html = await s_httpClient.GetStringAsync(URL);
return Regex.Matches(html, @"\.NET").Count;
}
// </ExtractDataFromNetwork>
static async Task Main()
{
Console.WriteLine("Application started.");
Console.WriteLine("Counting '.NET' phrase in websites...");
int total = 0;
foreach (string url in s_urlList)
{
var result = await GetDotNetCount(url);
Console.WriteLine($"{url}: {result}");
total += result;
}
Console.WriteLine("Total: " + total);
Console.WriteLine("Retrieving User objects with list of IDs...");
IEnumerable<int> ids = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
var users = await GetUsersAsync(ids);
foreach (User? user in users)
{
Console.WriteLine($"{user.id}: isEnabled={user.isEnabled}");
}
Console.WriteLine("Application ending.");
}
}
// Example output:
//
// Application started.
// Counting '.NET' phrase in websites...
// https://learn.microsoft.com: 0
// https://learn.microsoft.com/aspnet/core: 57
// https://learn.microsoft.com/azure: 1
// https://learn.microsoft.com/azure/devops: 2
// https://learn.microsoft.com/dotnet: 83
// https://learn.microsoft.com/dotnet/desktop/wpf/get-started/create-app-visual-studio: 31
// https://learn.microsoft.com/education: 0
// https://learn.microsoft.com/shows/net-core-101/what-is-net: 42
// https://learn.microsoft.com/enterprise-mobility-security: 0
// https://learn.microsoft.com/gaming: 0
// https://learn.microsoft.com/graph: 0
// https://learn.microsoft.com/microsoft-365: 0
// https://learn.microsoft.com/office: 0
// https://learn.microsoft.com/powershell: 0
// https://learn.microsoft.com/sql: 0
// https://learn.microsoft.com/surface: 0
// https://dotnetfoundation.org: 16
// https://learn.microsoft.com/visualstudio: 0
// https://learn.microsoft.com/windows: 0
// https://learn.microsoft.com/maui: 6
// Total: 238
// Retrieving User objects with list of IDs...
// 1: isEnabled= False
// 2: isEnabled= False
// 3: isEnabled= False
// 4: isEnabled= False
// 5: isEnabled= False
// 6: isEnabled= False
// 7: isEnabled= False
// 8: isEnabled= False
// 9: isEnabled= False
// 0: isEnabled= False
// Application ending.
