CKTIS / C#
Task — asynchrone bewerkingen en wachten op groepen taken
Task staat voor een asynchrone bewerking; Task<T> levert ook het resultaat. Lees meer over de verschillen tussen Task.Yield, het blokkerende Task.WaitAll en het niet-blokkerende Task.WhenAll, waaronder de volgorde van resultaten en foutafhandeling.
Versie: .NET 10; repository net10.0 and LangVersion=preview; feature versions require per-entry verification
Syntax
await Task.Yield();
Task.WaitAll(tasks);
Task combined = Task.WhenAll(tasks);
TResult[] results = await Task.WhenAll<TResult>(resultTasks);System.Threading.Tasks.Task staat voor een asynchrone bewerking zonder resultaatwaarde; Task<T> levert een resultaat van het type T. Een task is niet hetzelfde als een thread. De hier beschreven aanroepen zijn beschikbaar in .NET 10 en vereisen geen preview-taalfuncties.
await Task.Yield() dwingt af dat het resterende deel van de methode asynchroon wordt hervat. De aanroep Task.Yield() retourneert YieldAwaitable, niet Task; de volledige expressie await Task.Yield() levert geen waarde op. De continuation wordt aan de huidige synchronisatiecontext doorgegeven als die een instantie is van een type dat van SynchronizationContext is afgeleid. Als er geen huidige context is of als het type ervan precies SynchronizationContext is, wordt in plaats daarvan de huidige task scheduler gebruikt. Dit garandeert geen threadwissel en ook geen responsieve gebruikersinterface.
Task.WaitAll(tasks) blokkeert de aanroepende thread totdat alle tasks zijn voltooid. Fouten of annuleringen van tasks worden gemeld via AggregateException. Het blokkeren van een thread die continuations nodig hebben, kan een deadlock veroorzaken; gebruik in asynchrone code bij voorkeur await Task.WhenAll(tasks). Het annuleren van alleen het wachten via een overload met token annuleert de tasks niet.
Task.WhenAll(tasks) retourneert een gecombineerde task zonder de aanroepende thread te blokkeren. Voor Task<T>[] is het resultaat van await een array in de volgorde van invoer, niet de volgorde waarin de tasks zijn voltooid. Als een task mislukt, wordt de status Faulted; zijn er geen fouten maar is er wel een annulering, dan is de status Canceled; anders slaagt de bewerking. Lege invoer slaagt onmiddellijk. Het voorbeeld geeft de resultaten pas na await weer; Task.WaitAll wordt alleen getoond met al voltooide tasks.
Voorbeelden
using System;
using System.Threading.Tasks;
internal static class Program
{
private static async Task Main()
{
Task<int>[] tasks = { DoubleAsync(3), DoubleAsync(5) };
int[] results = await Task.WhenAll(tasks);
Console.WriteLine(string.Join(", ", results));
Task[] completed = { Task.CompletedTask, Task.CompletedTask };
Task.WaitAll(completed);
Console.WriteLine("WaitAll completed");
}
private static async Task<int> DoubleAsync(int value)
{
await Task.Yield();
return value * 2;
}
}Resultaat
6, 10 WaitAll completed
De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.