Task Klas
Definitie
Belangrijk
Bepaalde informatie heeft betrekking op een voorlopige productversie die aanzienlijk kan worden gewijzigd voordat deze wordt uitgebracht. Microsoft biedt geen enkele expliciete of impliciete garanties met betrekking tot de informatie die hier wordt verstrekt.
Vertegenwoordigt een asynchrone bewerking.
public ref class Task : IAsyncResultpublic ref class Task : IAsyncResult, IDisposablepublic class Task : IAsyncResultpublic class Task : IAsyncResult, IDisposabletype Task = class
interface IAsyncResulttype Task = class
interface IAsyncResult
interface IDisposablePublic Class Task
Implements IAsyncResultPublic Class Task
Implements IAsyncResult, IDisposable- Overname
-
Task
- Afgeleid
- Implementeringen
Opmerkingen
De Task klasse vertegenwoordigt één bewerking die geen waarde retourneert en die meestal asynchroon wordt uitgevoerd. Task objecten zijn een van de centrale onderdelen van het asynchrone patroon op basis van taken. Omdat het werk dat door een Task object wordt uitgevoerd, doorgaans asynchroon wordt uitgevoerd op een thread in een thread-pool in plaats van synchroon op de hoofdtoepassingsthread, kunt u de Status eigenschap, evenals de IsCanceled, IsCompleted en IsFaulted eigenschappen, gebruiken om de status van een task te bepalen. Meestal wordt een lambda-expressie gebruikt om het werk op te geven dat de taak moet uitvoeren.
Voor bewerkingen die waarden retourneren, gebruikt u de Task<TResult> klasse.
Taak creatie
In het volgende voorbeeld worden vier taken gemaakt en uitgevoerd. Drie taken voeren een Action<T> gemachtigde met de naam actionuit, die een argument van het type Objectaccepteert. Een vierde taak voert een lambda-expressie (een Action gemachtigde) uit die inline is gedefinieerd in de aanroep van de methode voor het maken van taken. Elke taak wordt geïnstantieerd en op een andere manier uitgevoerd:
De taak
t1wordt geïnstantieerd door een taakklasseconstructor aan te roepen, maar wordt pas gestart door de Start() methode aan te roepen nadat de taakt2is gestart.De taak
t2wordt geïnstantieerd en gestart in één methode-aanroep door de methode aan te TaskFactory.StartNew(Action<Object>, Object) roepen.De taak
t3wordt geïnstantieerd en gestart in één methode-aanroep door de methode aan te Run(Action) roepen.De taak
t4wordt synchroon uitgevoerd op de hoofdthread door de methode aan te RunSynchronously() roepen.
Omdat de taak t4 synchroon wordt uitgevoerd, wordt deze uitgevoerd op de hoofdtoepassingsthread. De resterende taken worden meestal asynchroon uitgevoerd op een of meer threads in de threadpool.
using System;
using System.Threading;
using System.Threading.Tasks;
class Example
{
static void Main()
{
Action<object> action = (object obj) =>
{
Console.WriteLine("Task={0}, obj={1}, Thread={2}",
Task.CurrentId, obj,
Thread.CurrentThread.ManagedThreadId);
};
// Create a task but do not start it.
Task t1 = new Task(action, "alpha");
// Construct a started task
Task t2 = Task.Factory.StartNew(action, "beta");
// Block the main thread to demonstrate that t2 is executing
t2.Wait();
// Launch t1
t1.Start();
Console.WriteLine("t1 has been launched. (Main Thread={0})",
Thread.CurrentThread.ManagedThreadId);
// Wait for the task to finish.
t1.Wait();
// Construct a started task using Task.Run.
String taskData = "delta";
Task t3 = Task.Run( () => {Console.WriteLine("Task={0}, obj={1}, Thread={2}",
Task.CurrentId, taskData,
Thread.CurrentThread.ManagedThreadId);
});
// Wait for the task to finish.
t3.Wait();
// Construct an unstarted task
Task t4 = new Task(action, "gamma");
// Run it synchronously
t4.RunSynchronously();
// Although the task was run synchronously, it is a good practice
// to wait for it in the event exceptions were thrown by the task.
t4.Wait();
}
}
// The example displays output like the following:
// Task=1, obj=beta, Thread=3
// t1 has been launched. (Main Thread=1)
// Task=2, obj=alpha, Thread=4
// Task=3, obj=delta, Thread=3
// Task=4, obj=gamma, Thread=1
open System.Threading
open System.Threading.Tasks
let action =
fun (obj: obj) -> printfn $"Task={Task.CurrentId}, obj={obj}, Thread={Thread.CurrentThread.ManagedThreadId}"
// Create a task but do not start it.
let t1 = new Task(action, "alpha")
// Construct a started task
let t2 = Task.Factory.StartNew(action, "beta")
// Block the main thread to demonstrate that t2 is executing
t2.Wait()
// Launch t1
t1.Start()
printfn $"t1 has been launched. (Main Thread={Thread.CurrentThread.ManagedThreadId})"
// Wait for the task to finish.
t1.Wait()
// Construct a started task using Task.Run.
let taskData = "delta"
let t3 =
Task.Run(fun () -> printfn $"Task={Task.CurrentId}, obj={taskData}, Thread={Thread.CurrentThread.ManagedThreadId}")
// Wait for the task to finish.
t3.Wait()
// Construct an unstarted task
let t4 = new Task(action, "gamma")
// Run it synchronously
t4.RunSynchronously()
// Although the task was run synchronously, it is a good practice
// to wait for it in the event exceptions were thrown by the task.
t4.Wait()
// The example displays output like the following:
// Task=1, obj=beta, Thread=3
// t1 has been launched. (Main Thread=1)
// Task=2, obj=alpha, Thread=4
// Task=3, obj=delta, Thread=3
// Task=4, obj=gamma, Thread=1
Imports System.Threading
Imports System.Threading.Tasks
Module Example2
Public Sub Main()
Dim action As Action(Of Object) =
Sub(obj As Object)
Console.WriteLine("Task={0}, obj={1}, Thread={2}",
Task.CurrentId, obj,
Thread.CurrentThread.ManagedThreadId)
End Sub
' Construct an unstarted task
Dim t1 As New Task(action, "alpha")
' Construct a started task
Dim t2 As Task = Task.Factory.StartNew(action, "beta")
' Block the main thread to demonstrate that t2 is executing
t2.Wait()
' Launch t1
t1.Start()
Console.WriteLine("t1 has been launched. (Main Thread={0})",
Thread.CurrentThread.ManagedThreadId)
' Wait for the task to finish.
t1.Wait()
' Construct a started task using Task.Run.
Dim taskData As String = "delta"
Dim t3 As Task = Task.Run(Sub()
Console.WriteLine("Task={0}, obj={1}, Thread={2}",
Task.CurrentId, taskData,
Thread.CurrentThread.ManagedThreadId)
End Sub)
' Wait for the task to finish.
t3.Wait()
' Construct an unstarted task
Dim t4 As New Task(action, "gamma")
' Run it synchronously
t4.RunSynchronously()
' Although the task was run synchronously, it is a good practice
' to wait for it in the event exceptions were thrown by the task.
t4.Wait()
End Sub
End Module
' The example displays output like the following:
' Task=1, obj=beta, Thread=3
' t1 has been launched. (Main Thread=1)
' Task=2, obj=alpha, Thread=3
' Task=3, obj=delta, Thread=3
' Task=4, obj=gamma, Thread=1
Een taak maken en uitvoeren
U kunt Task exemplaren op verschillende manieren maken. De meest voorkomende benadering is het aanroepen van de statische Run methode. De Run methode biedt een eenvoudige manier om een taak te starten met behulp van standaardwaarden en zonder extra parameters. In het volgende voorbeeld wordt de Run(Action) methode gebruikt om een taak te starten die wordt herhaald en vervolgens het aantal lusiteraties weer te geven:
using System;
using System.Threading.Tasks;
public class Example
{
public static async Task Main()
{
await Task.Run( () => {
// Just loop.
int ctr = 0;
for (ctr = 0; ctr <= 1000000; ctr++)
{}
Console.WriteLine("Finished {0} loop iterations",
ctr);
} );
}
}
// The example displays the following output:
// Finished 1000001 loop iterations
open System.Threading.Tasks
let main =
task {
do!
Task.Run(fun () ->
for i = 0 to 1000000 do
printfn $"Finished {i} loop iterations")
}
main.Wait()
// The example displays the following output:
// Finished 1000001 loop iterations
Imports System.Threading.Tasks
Module Example1
Public Sub Main()
Dim t As Task = Task.Run(Sub()
' Just loop.
Dim ctr As Integer = 0
For ctr = 0 To 1000000
Next
Console.WriteLine("Finished {0} loop iterations",
ctr)
End Sub)
t.Wait()
End Sub
End Module
' The example displays the following output:
' Finished 1000001 loop iterations
Een alternatief is de statische TaskFactory.StartNew methode. De Task.Factory eigenschap retourneert een TaskFactory object. Met overbelastingen van de TaskFactory.StartNew methode kunt u parameters opgeven die moeten worden doorgegeven aan de opties voor het maken van taken en een taakplanner. In het volgende voorbeeld wordt de TaskFactory.StartNew methode gebruikt om een taak te starten. Het is functioneel gelijk aan de code in het vorige voorbeeld.
using System;
using System.Threading.Tasks;
public class Example
{
public static void Main()
{
Task t = Task.Factory.StartNew( () => {
// Just loop.
int ctr = 0;
for (ctr = 0; ctr <= 1000000; ctr++)
{}
Console.WriteLine("Finished {0} loop iterations",
ctr);
} );
t.Wait();
}
}
// The example displays the following output:
// Finished 1000001 loop iterations
open System.Threading.Tasks
let t =
Task.Factory.StartNew(fun () ->
// Just loop.
for i = 0 to 1000000 do
printfn $"Finished {i} loop iterations")
t.Wait()
// The example displays the following output:
// Finished 1000001 loop iterations
Imports System.Threading.Tasks
Module Example3
Public Sub Main()
Dim t As Task = Task.Factory.StartNew(Sub()
' Just loop.
Dim ctr As Integer = 0
For ctr = 0 To 1000000
Next
Console.WriteLine("Finished {0} loop iterations",
ctr)
End Sub)
t.Wait()
End Sub
End Module
' The example displays the following output:
' Finished 1000001 loop iterations
Zie Asynchrone programmering op basis van taken voor meer volledige voorbeelden.
Afzonderlijke taak maken en uitvoeren
De Task klasse biedt ook constructors die de taak initialiseren, maar die deze niet plannen voor uitvoering. Om prestatieredenen is de Task.Run of TaskFactory.StartNew methode het voorkeursmechanisme voor het maken en plannen van rekentaken, maar voor scenario's waarbij het maken en plannen moet worden gescheiden, kunt u de constructors gebruiken en vervolgens de methode aanroepen om de Task.Start taak op een later tijdstip te plannen voor uitvoering.
Wacht totdat een taak is voltooid
Omdat taken doorgaans asynchroon worden uitgevoerd op een thread van een threadgroep, gaat de thread die de taak maakt en start, door met de uitvoering zodra de taak is geïnstantieerd. In sommige gevallen kan de app, wanneer de aanroepende thread de belangrijkste thread van de toepassing is, worden beëindigd voordat de taak daadwerkelijk begint met de uitvoering. In andere gevallen is het mogelijk dat de logica van uw toepassing vereist dat de aanroepende thread alleen wordt uitgevoerd wanneer een of meer taken de uitvoering hebben voltooid. U kunt de uitvoering van de aanroepende thread en de asynchrone taken die worden gestart synchroniseren door een Wait methode aan te roepen om te wachten tot een of meer taken zijn voltooid.
Als u wilt wachten tot één taak is voltooid, kunt u de Task.Wait bijbehorende methode aanroepen. Een aanroep van de Wait methode blokkeert de aanroepende thread totdat de uitvoering van het exemplaar van één klasse is afgerond.
In het volgende voorbeeld wordt de methode zonder parameters Wait() aangeroepen om onvoorwaardelijke te wachten totdat een taak is voltooid. De taak simuleert werk door de Thread.Sleep methode aan te roepen om twee seconden te slapen.
using System;
using System.Threading;
using System.Threading.Tasks;
class Program
{
static Random rand = new Random();
static void Main()
{
// Wait on a single task with no timeout specified.
Task taskA = Task.Run( () => Thread.Sleep(2000));
Console.WriteLine("taskA Status: {0}", taskA.Status);
try {
taskA.Wait();
Console.WriteLine("taskA Status: {0}", taskA.Status);
}
catch (AggregateException) {
Console.WriteLine("Exception in taskA.");
}
}
}
// The example displays output like the following:
// taskA Status: WaitingToRun
// taskA Status: RanToCompletion
open System
open System.Threading
open System.Threading.Tasks
let rand = Random()
// Wait on a single task with no timeout specified.
let taskA = Task.Run(fun () -> Thread.Sleep 2000)
printfn $"taskA Status: {taskA.Status}"
try
taskA.Wait()
printfn $"taskA Status: {taskA.Status}"
with :? AggregateException ->
printfn "Exception in taskA."
// The example displays output like the following:
// taskA Status: WaitingToRun
// taskA Status: RanToCompletion
Imports System.Threading
Imports System.Threading.Tasks
Module Example4
Public Sub Main()
' Wait on a single task with no timeout specified.
Dim taskA = Task.Run(Sub() Thread.Sleep(2000))
Console.WriteLine("taskA Status: {0}", taskA.Status)
Try
taskA.Wait()
Console.WriteLine("taskA Status: {0}", taskA.Status)
Catch e As AggregateException
Console.WriteLine("Exception in taskA.")
End Try
End Sub
End Module
' The example displays output like the following:
' taskA Status: WaitingToRun
' taskA Status: RanToCompletion
U kunt ook voorwaardelijk wachten totdat een taak is voltooid. De Wait(Int32) en Wait(TimeSpan) methoden blokkeren de aanroepende thread totdat de taak is voltooid of een time-outinterval is verstreken, afhankelijk van wat het eerst voorkomt. Aangezien in het volgende voorbeeld een taak wordt gestart die twee seconden in slaapstand gaat, maar een time-outwaarde van één seconde definieert, blokkeert de aanroepende thread totdat de time-out verloopt en voordat de taak is uitgevoerd.
using System;
using System.Threading;
using System.Threading.Tasks;
public class Example
{
public static void Main()
{
// Wait on a single task with a timeout specified.
Task taskA = Task.Run( () => Thread.Sleep(2000));
try {
taskA.Wait(1000); // Wait for 1 second.
bool completed = taskA.IsCompleted;
Console.WriteLine("Task A completed: {0}, Status: {1}",
completed, taskA.Status);
if (!completed)
Console.WriteLine("Timed out before task A completed.");
}
catch (AggregateException) {
Console.WriteLine("Exception in taskA.");
}
}
}
// The example displays output like the following:
// Task A completed: False, Status: Running
// Timed out before task A completed.
open System
open System.Threading
open System.Threading.Tasks
// Wait on a single task with a timeout specified.
let taskA = Task.Run(fun () -> Thread.Sleep 2000)
try
taskA.Wait 1000 |> ignore // Wait for 1 second.
let completed = taskA.IsCompleted
printfn $"Task A completed: {completed}, Status: {taskA.Status}"
if not completed then
printfn "Timed out before task A completed."
with :? AggregateException ->
printfn "Exception in taskA."
// The example displays output like the following:
// Task A completed: False, Status: Running
// Timed out before task A completed.
Imports System.Threading
Imports System.Threading.Tasks
Module Example5
Public Sub Main()
' Wait on a single task with a timeout specified.
Dim taskA As Task = Task.Run(Sub() Thread.Sleep(2000))
Try
taskA.Wait(1000) ' Wait for 1 second.
Dim completed As Boolean = taskA.IsCompleted
Console.WriteLine("Task.Completed: {0}, Status: {1}",
completed, taskA.Status)
If Not completed Then
Console.WriteLine("Timed out before task A completed.")
End If
Catch e As AggregateException
Console.WriteLine("Exception in taskA.")
End Try
End Sub
End Module
' The example displays the following output:
' Task A completed: False, Status: Running
' Timed out before task A completed.
U kunt ook een annuleringstoken opgeven door de Wait(CancellationToken) en Wait(Int32, CancellationToken) methoden aan te roepen. Als de eigenschap van IsCancellationRequested het token is true of wordt true terwijl de Wait methode wordt uitgevoerd, genereert de methode een OperationCanceledException.
In sommige gevallen wilt u misschien wachten tot de eerste van een reeks uitvoertaken is voltooid, maar het maakt niet uit welke taak het is. Hiervoor kunt u een van de overbelastingen van de Task.WaitAny methode aanroepen. In het volgende voorbeeld worden drie taken gemaakt, waarvan elke taak een periode "slaapt" die wordt bepaald door een generator voor willekeurige getallen. De WaitAny(Task[]) methode wacht totdat de eerste taak is voltooid. In het voorbeeld wordt vervolgens informatie weergegeven over de status van alle drie de taken.
using System;
using System.Threading;
using System.Threading.Tasks;
public class Example
{
public static void Main()
{
var tasks = new Task[3];
var rnd = new Random();
for (int ctr = 0; ctr <= 2; ctr++)
tasks[ctr] = Task.Run( () => Thread.Sleep(rnd.Next(500, 3000)));
try {
int index = Task.WaitAny(tasks);
Console.WriteLine("Task #{0} completed first.\n", tasks[index].Id);
Console.WriteLine("Status of all tasks:");
foreach (var t in tasks)
Console.WriteLine(" Task #{0}: {1}", t.Id, t.Status);
}
catch (AggregateException) {
Console.WriteLine("An exception occurred.");
}
}
}
// The example displays output like the following:
// Task #1 completed first.
//
// Status of all tasks:
// Task #3: Running
// Task #1: RanToCompletion
// Task #4: Running
open System
open System.Threading
open System.Threading.Tasks
let rnd = new Random()
let tasks =
[| for _ = 0 to 2 do
Task.Run(fun () -> rnd.Next(500, 3000) |> Thread.Sleep) |]
try
let index = Task.WaitAny tasks
printfn $"Task #{tasks[index].Id} completed first.\n"
printfn "Status of all tasks:"
for t in tasks do
printfn $" Task #{t.Id}: {t.Status}"
with :? AggregateException ->
printfn "An exception occurred."
// The example displays output like the following:
// Task #1 completed first.
//
// Status of all tasks:
// Task #3: Running
// Task #1: RanToCompletion
// Task #4: Running
Imports System.Threading
Imports System.Threading.Tasks
Module Example8
Public Sub Main()
Dim tasks(2) As Task
Dim rnd As New Random()
For ctr As Integer = 0 To 2
tasks(ctr) = Task.Run(Sub() Thread.Sleep(rnd.Next(500, 3000)))
Next
Try
Dim index As Integer = Task.WaitAny(tasks)
Console.WriteLine("Task #{0} completed first.", tasks(index).Id)
Console.WriteLine()
Console.WriteLine("Status of all tasks:")
For Each t In tasks
Console.WriteLine(" Task #{0}: {1}", t.Id, t.Status)
Next
Catch e As AggregateException
Console.WriteLine("An exception occurred.")
End Try
End Sub
End Module
' The example displays output like the following:
' Task #1 completed first.
'
' Status of all tasks:
' Task #3: Running
' Task #1: RanToCompletion
' Task #4: Running
U kunt ook wachten totdat alle taken zijn voltooid door de methode aan te WaitAll roepen. In het volgende voorbeeld worden tien taken gemaakt, wordt gewacht tot alle tien zijn voltooid en wordt de status weergegeven.
using System;
using System.Threading;
using System.Threading.Tasks;
public class Example
{
public static void Main()
{
// Wait for all tasks to complete.
Task[] tasks = new Task[10];
for (int i = 0; i < 10; i++)
{
tasks[i] = Task.Run(() => Thread.Sleep(2000));
}
try {
Task.WaitAll(tasks);
}
catch (AggregateException ae) {
Console.WriteLine("One or more exceptions occurred: ");
foreach (var ex in ae.Flatten().InnerExceptions)
Console.WriteLine(" {0}", ex.Message);
}
Console.WriteLine("Status of completed tasks:");
foreach (var t in tasks)
Console.WriteLine(" Task #{0}: {1}", t.Id, t.Status);
}
}
// The example displays the following output:
// Status of completed tasks:
// Task #2: RanToCompletion
// Task #1: RanToCompletion
// Task #3: RanToCompletion
// Task #4: RanToCompletion
// Task #6: RanToCompletion
// Task #5: RanToCompletion
// Task #7: RanToCompletion
// Task #8: RanToCompletion
// Task #9: RanToCompletion
// Task #10: RanToCompletion
open System
open System.Threading
open System.Threading.Tasks
// Wait for all tasks to complete.
let tasks =
[| for _ = 0 to 9 do
Task.Run(fun () -> Thread.Sleep 2000) |]
try
Task.WaitAll tasks
with :? AggregateException as ae ->
printfn "One or more exceptions occurred: "
for ex in ae.Flatten().InnerExceptions do
printfn $" {ex.Message}"
printfn "Status of completed tasks:"
for t in tasks do
printfn $" Task #{t.Id}: {t.Status}"
// The example displays the following output:
// Status of completed tasks:
// Task #2: RanToCompletion
// Task #1: RanToCompletion
// Task #3: RanToCompletion
// Task #4: RanToCompletion
// Task #6: RanToCompletion
// Task #5: RanToCompletion
// Task #7: RanToCompletion
// Task #8: RanToCompletion
// Task #9: RanToCompletion
// Task #10: RanToCompletion
Imports System.Threading
Imports System.Threading.Tasks
Module Example6
Public Sub Main()
' Wait for all tasks to complete.
Dim tasks(9) As Task
For i As Integer = 0 To 9
tasks(i) = Task.Run(Sub() Thread.Sleep(2000))
Next
Try
Task.WaitAll(tasks)
Catch ae As AggregateException
Console.WriteLine("One or more exceptions occurred: ")
For Each ex In ae.Flatten().InnerExceptions
Console.WriteLine(" {0}", ex.Message)
Next
End Try
Console.WriteLine("Status of completed tasks:")
For Each t In tasks
Console.WriteLine(" Task #{0}: {1}", t.Id, t.Status)
Next
End Sub
End Module
' The example displays the following output:
' Status of completed tasks:
' Task #2: RanToCompletion
' Task #1: RanToCompletion
' Task #3: RanToCompletion
' Task #4: RanToCompletion
' Task #6: RanToCompletion
' Task #5: RanToCompletion
' Task #7: RanToCompletion
' Task #8: RanToCompletion
' Task #9: RanToCompletion
' Task #10: RanToCompletion
Houd er rekening mee dat wanneer u wacht tot een of meer taken zijn voltooid, eventuele uitzonderingen in de actieve taken worden doorgegeven in de thread die de Wait methode aanroept, zoals in het volgende voorbeeld wordt weergegeven. Er worden 12 taken gestart, waarvan drie normaal worden voltooid en waarvan er drie tot een uitzondering leiden. Van de resterende zes taken worden drie geannuleerd voordat ze worden gestart en drie worden geannuleerd terwijl ze worden uitgevoerd. Uitzonderingen worden gegenereerd in de WaitAll methode-aanroep en worden verwerkt door een try/catch blok.
using System;
using System.Threading;
using System.Threading.Tasks;
public class Example
{
public static void Main()
{
// Create a cancellation token and cancel it.
var source1 = new CancellationTokenSource();
var token1 = source1.Token;
source1.Cancel();
// Create a cancellation token for later cancellation.
var source2 = new CancellationTokenSource();
var token2 = source2.Token;
// Create a series of tasks that will complete, be cancelled,
// timeout, or throw an exception.
Task[] tasks = new Task[12];
for (int i = 0; i < 12; i++)
{
switch (i % 4)
{
// Task should run to completion.
case 0:
tasks[i] = Task.Run(() => Thread.Sleep(2000));
break;
// Task should be set to canceled state.
case 1:
tasks[i] = Task.Run( () => Thread.Sleep(2000),
token1);
break;
case 2:
// Task should throw an exception.
tasks[i] = Task.Run( () => { throw new NotSupportedException(); } );
break;
case 3:
// Task should examine cancellation token.
tasks[i] = Task.Run( () => { Thread.Sleep(2000);
if (token2.IsCancellationRequested)
token2.ThrowIfCancellationRequested();
Thread.Sleep(500); }, token2);
break;
}
}
Thread.Sleep(250);
source2.Cancel();
try {
Task.WaitAll(tasks);
}
catch (AggregateException ae) {
Console.WriteLine("One or more exceptions occurred:");
foreach (var ex in ae.InnerExceptions)
Console.WriteLine(" {0}: {1}", ex.GetType().Name, ex.Message);
}
Console.WriteLine("\nStatus of tasks:");
foreach (var t in tasks) {
Console.WriteLine(" Task #{0}: {1}", t.Id, t.Status);
if (t.Exception != null) {
foreach (var ex in t.Exception.InnerExceptions)
Console.WriteLine(" {0}: {1}", ex.GetType().Name,
ex.Message);
}
}
}
}
// The example displays output like the following:
// One or more exceptions occurred:
// TaskCanceledException: A task was canceled.
// NotSupportedException: Specified method is not supported.
// TaskCanceledException: A task was canceled.
// TaskCanceledException: A task was canceled.
// NotSupportedException: Specified method is not supported.
// TaskCanceledException: A task was canceled.
// TaskCanceledException: A task was canceled.
// NotSupportedException: Specified method is not supported.
// TaskCanceledException: A task was canceled.
//
// Status of tasks:
// Task #13: RanToCompletion
// Task #1: Canceled
// Task #3: Faulted
// NotSupportedException: Specified method is not supported.
// Task #8: Canceled
// Task #14: RanToCompletion
// Task #4: Canceled
// Task #6: Faulted
// NotSupportedException: Specified method is not supported.
// Task #7: Canceled
// Task #15: RanToCompletion
// Task #9: Canceled
// Task #11: Faulted
// NotSupportedException: Specified method is not supported.
// Task #12: Canceled
open System
open System.Threading
open System.Threading.Tasks
// Create a cancellation token and cancel it.
let source1 = new CancellationTokenSource()
let token1 = source1.Token
source1.Cancel()
// Create a cancellation token for later cancellation.
let source2 = new CancellationTokenSource()
let token2 = source2.Token
// Create a series of tasks that will complete, be cancelled,
// timeout, or throw an exception.
let tasks =
[| for i in 0..11 do
match i % 4 with
// Task should run to completion.
| 0 -> Task.Run(fun () -> Thread.Sleep 2000)
// Task should be set to canceled state.
| 1 -> Task.Run(fun () -> Thread.Sleep 2000, token1)
// Task should throw an exception.
| 2 -> Task.Run(fun () -> NotSupportedException())
// Task should examine cancellation token.
| _ ->
Task.Run(fun () ->
Thread.Sleep 2000
if token2.IsCancellationRequested then
token2.ThrowIfCancellationRequested()
Thread.Sleep 500, token2) |]
Thread.Sleep 250
source2.Cancel()
try
Task.WaitAll tasks
with :? AggregateException as ae ->
printfn "One or more exceptions occurred:"
for ex in ae.InnerExceptions do
printfn $" {ex.GetType().Name}: {ex.Message}"
printfn "\nStatus of tasks:"
for t in tasks do
printfn $" Task #{t.Id}: {t.Status}"
if isNull t.Exception |> not then
for ex in t.Exception.InnerExceptions do
printfn $" {ex.GetType().Name}: {ex.Message}"
// The example displays output like the following:
// One or more exceptions occurred:
// TaskCanceledException: A task was canceled.
// NotSupportedException: Specified method is not supported.
// TaskCanceledException: A task was canceled.
// TaskCanceledException: A task was canceled.
// NotSupportedException: Specified method is not supported.
// TaskCanceledException: A task was canceled.
// TaskCanceledException: A task was canceled.
// NotSupportedException: Specified method is not supported.
// TaskCanceledException: A task was canceled.
//
// Status of tasks:
// Task #13: RanToCompletion
// Task #1: Canceled
// Task #3: Faulted
// NotSupportedException: Specified method is not supported.
// Task #8: Canceled
// Task #14: RanToCompletion
// Task #4: Canceled
// Task #6: Faulted
// NotSupportedException: Specified method is not supported.
// Task #7: Canceled
// Task #15: RanToCompletion
// Task #9: Canceled
// Task #11: Faulted
// NotSupportedException: Specified method is not supported.
// Task #12: Canceled
Imports System.Threading
Imports System.Threading.Tasks
Module Example7
Public Sub Main()
' Create a cancellation token and cancel it.
Dim source1 As New CancellationTokenSource()
Dim token1 As CancellationToken = source1.Token
source1.Cancel()
' Create a cancellation token for later cancellation.
Dim source2 As New CancellationTokenSource()
Dim token2 As CancellationToken = source2.Token
' Create a series of tasks that will complete, be cancelled,
' timeout, or throw an exception.
Dim tasks(11) As Task
For i As Integer = 0 To 11
Select Case i Mod 4
' Task should run to completion.
Case 0
tasks(i) = Task.Run(Sub() Thread.Sleep(2000))
' Task should be set to canceled state.
Case 1
tasks(i) = Task.Run(Sub() Thread.Sleep(2000), token1)
Case 2
' Task should throw an exception.
tasks(i) = Task.Run(Sub()
Throw New NotSupportedException()
End Sub)
Case 3
' Task should examine cancellation token.
tasks(i) = Task.Run(Sub()
Thread.Sleep(2000)
If token2.IsCancellationRequested Then
token2.ThrowIfCancellationRequested()
End If
Thread.Sleep(500)
End Sub, token2)
End Select
Next
Thread.Sleep(250)
source2.Cancel()
Try
Task.WaitAll(tasks)
Catch ae As AggregateException
Console.WriteLine("One or more exceptions occurred:")
For Each ex In ae.InnerExceptions
Console.WriteLine(" {0}: {1}", ex.GetType().Name, ex.Message)
Next
End Try
Console.WriteLine()
Console.WriteLine("Status of tasks:")
For Each t In tasks
Console.WriteLine(" Task #{0}: {1}", t.Id, t.Status)
If t.Exception IsNot Nothing Then
For Each ex In t.Exception.InnerExceptions
Console.WriteLine(" {0}: {1}", ex.GetType().Name,
ex.Message)
Next
End If
Next
End Sub
End Module
' The example displays output like the following:
' One or more exceptions occurred:
' TaskCanceledException: A task was canceled.
' NotSupportedException: Specified method is not supported.
' TaskCanceledException: A task was canceled.
' TaskCanceledException: A task was canceled.
' NotSupportedException: Specified method is not supported.
' TaskCanceledException: A task was canceled.
' TaskCanceledException: A task was canceled.
' NotSupportedException: Specified method is not supported.
' TaskCanceledException: A task was canceled.
'
' Status of tasks:
' Task #13: RanToCompletion
' Task #1: Canceled
' Task #3: Faulted
' NotSupportedException: Specified method is not supported.
' Task #8: Canceled
' Task #14: RanToCompletion
' Task #4: Canceled
' Task #6: Faulted
' NotSupportedException: Specified method is not supported.
' Task #7: Canceled
' Task #15: RanToCompletion
' Task #9: Canceled
' Task #11: Faulted
' NotSupportedException: Specified method is not supported.
' Task #12: Canceled
Zie Uitzonderingsafhandeling voor meer informatie over het verwerken van uitzonderingen in asynchrone bewerkingen op basis van taken.
Taken en cultuur
Vanaf desktop-apps die zich richten op .NET Framework 4.6, wordt de cultuur van de thread die een taak maakt en aanroept, onderdeel van de context van de thread. Ongeacht de huidige cultuur van de thread waarop de taak wordt uitgevoerd, is de cultuur van de taak de cultuur van de aanroepende thread. Voor apps die gericht zijn op versies van .NET Framework vóór .NET Framework 4.6, is de cultuur van de taak de cultuur van de thread waarop de taak wordt uitgevoerd. Zie de sectie 'Asynchrone bewerkingen op basis van cultuur en taken' in het CultureInfo onderwerp voor meer informatie.
Note
Store-apps volgen de Windows Runtime bij het instellen en verkrijgen van de standaardcultuur.
Voor ontwikkelaars van foutopsporingsprogramma's
Voor ontwikkelaars die aangepaste foutopsporingsprogramma's implementeren, kunnen verschillende interne en persoonlijke leden van de taak nuttig zijn (deze kunnen veranderen van release naar release). Het m_taskId veld fungeert als het backing-archief voor de Id eigenschap, maar het openen van dit veld rechtstreeks vanuit een foutopsporingsprogramma kan efficiënter zijn dan het openen van dezelfde waarde via de gettermethode van de eigenschap (de s_taskIdCounter teller wordt gebruikt om de volgende beschikbare id voor een taak op te halen). Op dezelfde manier slaat het m_stateFlags veld informatie op over de huidige levenscyclusfase van de taak, informatie die ook toegankelijk is via de Status eigenschap. In m_action het veld wordt een verwijzing opgeslagen naar de gemachtigde van de taak en in het m_stateObject veld wordt de asynchrone status opgeslagen die door de ontwikkelaar aan de taak is doorgegeven. Ten slotte dient de InternalWait methode voor foutopsporingsprogramma's die stackframes parseren, een mogelijke markering voor wanneer een taak een wachtbewerking invoert.
Constructors
| Name | Description |
|---|---|
| Task(Action, CancellationToken, TaskCreationOptions) |
Initialiseert een nieuwe Task met de opgegeven actie en opties voor het maken. |
| Task(Action, CancellationToken) |
Initialiseert een nieuwe Task met de opgegeven actie en CancellationToken. |
| Task(Action, TaskCreationOptions) |
Initialiseert een nieuwe Task met de opgegeven actie en opties voor het maken. |
| Task(Action) |
Initialiseert een nieuwe Task met de opgegeven actie. |
| Task(Action<Object>, Object, CancellationToken, TaskCreationOptions) |
Initialiseert een nieuwe Task met de opgegeven actie, status en opties. |
| Task(Action<Object>, Object, CancellationToken) |
Initialiseert een nieuwe Task met de opgegeven actie, status en CancellationToken. |
| Task(Action<Object>, Object, TaskCreationOptions) |
Initialiseert een nieuwe Task met de opgegeven actie, status en opties. |
| Task(Action<Object>, Object) |
Initialiseert een nieuwe Task met de opgegeven actie en status. |
Eigenschappen
| Name | Description |
|---|---|
| AsyncState |
Hiermee wordt het statusobject opgehaald dat is opgegeven tijdens het Task maken of null als er geen is opgegeven. |
| CompletedTask |
Hiermee haalt u een taak op die al is voltooid. |
| CreationOptions |
Hiermee haalt u de TaskCreationOptions gebruikte gegevens op om deze taak te maken. |
| CurrentId |
Retourneert de id van de momenteel uitgevoerde Task. |
| Exception |
Hiermee haalt u de AggregateException oorzaak van de Task voortijdige beëindiging op. Als de Task voltooide bewerking is voltooid of nog geen uitzonderingen heeft gegenereerd, wordt dit geretourneerd |
| Factory |
Biedt toegang tot factory-methoden voor het maken en configureren en configureren Task van Task<TResult> exemplaren. |
| Id |
Hiermee haalt u een id voor dit Task exemplaar op. |
| IsCanceled |
Hiermee wordt aangegeven of deze Task instantie de uitvoering heeft voltooid omdat deze is geannuleerd. |
| IsCompleted |
Hiermee wordt een waarde opgehaald die aangeeft of de taak is voltooid. |
| IsCompletedSuccessfully |
Hiermee wordt aangegeven of de taak is voltooid. |
| IsFaulted |
Hiermee wordt aangegeven of de Task voltooide bewerking is veroorzaakt door een niet-verwerkte uitzondering. |
| Status |
Hiermee haalt u de TaskStatus taak op. |
Methoden
| Name | Description |
|---|---|
| ConfigureAwait(Boolean) |
Hiermee configureert u een wachter die wordt gebruikt om dit Taskte wachten. |
| ConfigureAwait(ConfigureAwaitOptions) |
Hiermee configureert u een wachter die wordt gebruikt om dit Taskte wachten. |
| ContinueWith(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler) |
Hiermee maakt u een vervolg die door de aanroeper verstrekte statusinformatie en een annuleringstoken ontvangt en dat wordt uitgevoerd wanneer het doel Task is voltooid. De voortzetting wordt uitgevoerd op basis van een set opgegeven voorwaarden en maakt gebruik van een opgegeven scheduler. |
| ContinueWith(Action<Task,Object>, Object, CancellationToken) |
Hiermee maakt u een vervolg dat door de aanroeper verstrekte statusinformatie en een annuleringstoken ontvangt en dat asynchroon wordt uitgevoerd wanneer het doel Task is voltooid. |
| ContinueWith(Action<Task,Object>, Object, TaskContinuationOptions) |
Hiermee maakt u een vervolg die door de aanroeper verstrekte statusinformatie ontvangt en wordt uitgevoerd wanneer het doel Task is voltooid. De voortzetting wordt uitgevoerd op basis van een set opgegeven voorwaarden. |
| ContinueWith(Action<Task,Object>, Object, TaskScheduler) |
Hiermee maakt u een vervolg dat door de aanroeper verstrekte statusinformatie ontvangt en asynchroon wordt uitgevoerd wanneer het doel Task is voltooid. De voortzetting maakt gebruik van een opgegeven scheduler. |
| ContinueWith(Action<Task,Object>, Object) |
Hiermee maakt u een vervolg die door de aanroeper verstrekte statusinformatie ontvangt en wordt uitgevoerd wanneer het doel Task is voltooid. |
| ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler) |
Hiermee maakt u een vervolg die wordt uitgevoerd wanneer de doeltaak concurreert op basis van de opgegeven TaskContinuationOptions. De voortzetting ontvangt een annuleringstoken en gebruikt een opgegeven scheduler. |
| ContinueWith(Action<Task>, CancellationToken) |
Hiermee maakt u een vervolg dat een annuleringstoken ontvangt en asynchroon wordt uitgevoerd wanneer het doel Task is voltooid. |
| ContinueWith(Action<Task>, TaskContinuationOptions) |
Hiermee maakt u een vervolg die wordt uitgevoerd wanneer de doeltaak wordt voltooid volgens de opgegeven TaskContinuationOptions. |
| ContinueWith(Action<Task>, TaskScheduler) |
Hiermee maakt u een vervolg dat asynchroon wordt uitgevoerd wanneer het doel Task is voltooid. De voortzetting maakt gebruik van een opgegeven scheduler. |
| ContinueWith(Action<Task>) |
Hiermee maakt u een vervolg dat asynchroon wordt uitgevoerd wanneer het doel Task is voltooid. |
| ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler) |
Hiermee maakt u een vervolg die wordt uitgevoerd op basis van de opgegeven opties voor taakvervolging wanneer het doel Task is voltooid en een waarde retourneert. De voortzetting ontvangt door de beller verstrekte statusinformatie en een annuleringstoken en gebruikt de opgegeven scheduler. |
| ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken) |
Hiermee maakt u een vervolg dat asynchroon wordt uitgevoerd wanneer het doel Task is voltooid en een waarde retourneert. De voortzetting ontvangt door de beller verstrekte statusinformatie en een annuleringstoken. |
| ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskContinuationOptions) |
Hiermee maakt u een vervolg die wordt uitgevoerd op basis van de opgegeven opties voor taakvervolging wanneer het doel Task is voltooid. De voortzetting ontvangt door de beller verstrekte statusinformatie. |
| ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskScheduler) |
Hiermee maakt u een vervolg dat asynchroon wordt uitgevoerd wanneer het doel Task is voltooid. De voortzetting ontvangt door de beller verstrekte statusinformatie en gebruikt een opgegeven scheduler. |
| ContinueWith<TResult>(Func<Task,Object,TResult>, Object) |
Hiermee maakt u een vervolg dat door de aanroeper verstrekte statusinformatie ontvangt en asynchroon wordt uitgevoerd wanneer het doel Task is voltooid en een waarde retourneert. |
| ContinueWith<TResult>(Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler) |
Hiermee maakt u een vervolg die wordt uitgevoerd op basis van de opgegeven vervolgopties en retourneert een waarde. De voortzetting wordt doorgegeven aan een annuleringstoken en maakt gebruik van een opgegeven scheduler. |
| ContinueWith<TResult>(Func<Task,TResult>, CancellationToken) |
Hiermee maakt u een vervolg dat asynchroon wordt uitgevoerd wanneer het doel Task is voltooid en een waarde retourneert. De voortzetting ontvangt een annuleringstoken. |
| ContinueWith<TResult>(Func<Task,TResult>, TaskContinuationOptions) |
Hiermee maakt u een vervolg die wordt uitgevoerd op basis van de opgegeven vervolgopties en retourneert een waarde. |
| ContinueWith<TResult>(Func<Task,TResult>, TaskScheduler) |
Hiermee maakt u een vervolg dat asynchroon wordt uitgevoerd wanneer het doel Task is voltooid en een waarde retourneert. De voortzetting maakt gebruik van een opgegeven scheduler. |
| ContinueWith<TResult>(Func<Task,TResult>) |
Hiermee maakt u een vervolg dat asynchroon wordt uitgevoerd wanneer het doel Task<TResult> is voltooid en een waarde retourneert. |
| Delay(Int32, CancellationToken) |
Hiermee maakt u een geannuleerde taak die na een opgegeven aantal milliseconden wordt voltooid. |
| Delay(Int32) |
Hiermee maakt u een taak die na een opgegeven aantal milliseconden wordt voltooid. |
| Delay(TimeSpan, CancellationToken) |
Hiermee maakt u een geannuleerde taak die na een opgegeven tijdsinterval wordt voltooid. |
| Delay(TimeSpan, TimeProvider, CancellationToken) |
Hiermee maakt u een geannuleerde taak die na een opgegeven tijdsinterval wordt voltooid. |
| Delay(TimeSpan, TimeProvider) |
Hiermee maakt u een taak die na een opgegeven tijdsinterval wordt voltooid. |
| Delay(TimeSpan) |
Hiermee maakt u een taak die na een opgegeven tijdsinterval wordt voltooid. |
| Dispose() |
Alle resources die door het huidige exemplaar van de Task klasse worden gebruikt, worden vrijgegeven. |
| Dispose(Boolean) |
Hiermee verwijdert u alle Taskonbeheerde resources. |
| Equals(Object) |
Bepaalt of het opgegeven object gelijk is aan het huidige object. (Overgenomen van Object) |
| FromCanceled(CancellationToken) |
Hiermee maakt u een Task die is voltooid vanwege annulering met een opgegeven annuleringstoken. |
| FromCanceled<TResult>(CancellationToken) |
Hiermee maakt u een Task<TResult> die is voltooid vanwege annulering met een opgegeven annuleringstoken. |
| FromException(Exception) |
Hiermee maakt u een Task die is voltooid met een opgegeven uitzondering. |
| FromException<TResult>(Exception) |
Hiermee maakt u een Task<TResult> die is voltooid met een opgegeven uitzondering. |
| FromResult<TResult>(TResult) |
Hiermee maakt u een Task<TResult> bewerking die is voltooid met het opgegeven resultaat. |
| GetAwaiter() |
Krijgt een wachter gebruikt om dit Taskte wachten. |
| GetHashCode() |
Fungeert als de standaardhashfunctie. (Overgenomen van Object) |
| GetType() |
Hiermee haalt u de Type huidige instantie op. (Overgenomen van Object) |
| MemberwiseClone() |
Hiermee maakt u een ondiepe kopie van de huidige Object. (Overgenomen van Object) |
| Run(Action, CancellationToken) |
Hiermee wordt het opgegeven werk dat moet worden uitgevoerd in de threadgroep in de wachtrij geplaatst en wordt een Task object geretourneerd dat het werk vertegenwoordigt. Met een annuleringstoken kan het werk worden geannuleerd als het nog niet is gestart. |
| Run(Action) |
Hiermee wordt het opgegeven werk dat moet worden uitgevoerd in de threadgroep in de wachtrij geplaatst en wordt een Task object geretourneerd dat het werk vertegenwoordigt. |
| Run(Func<Task>, CancellationToken) |
Hiermee wordt het opgegeven werk in de wachtrij geplaatst dat moet worden uitgevoerd in de threadgroep en wordt een proxy geretourneerd voor de taak die wordt geretourneerd door |
| Run(Func<Task>) |
Hiermee wordt het opgegeven werk in de wachtrij geplaatst dat moet worden uitgevoerd in de threadgroep en wordt een proxy geretourneerd voor de taak die wordt geretourneerd door |
| Run<TResult>(Func<Task<TResult>>, CancellationToken) |
Hiermee wordt het opgegeven werk in de wachtrij geplaatst dat moet worden uitgevoerd op de threadgroep en wordt een proxy geretourneerd voor de |
| Run<TResult>(Func<Task<TResult>>) |
Hiermee wordt het opgegeven werk in de wachtrij geplaatst dat moet worden uitgevoerd op de threadgroep en wordt een proxy geretourneerd voor de |
| Run<TResult>(Func<TResult>, CancellationToken) |
Hiermee wordt het opgegeven werk dat moet worden uitgevoerd in de threadgroep in de wachtrij geplaatst en wordt een |
| Run<TResult>(Func<TResult>) |
Hiermee wordt het opgegeven werk dat moet worden uitgevoerd in de threadgroep in de wachtrij geplaatst en wordt een Task<TResult> object geretourneerd dat het werk vertegenwoordigt. Met een annuleringstoken kan het werk worden geannuleerd als het nog niet is gestart. |
| RunSynchronously() |
Hiermee wordt de Task synchrone uitvoering uitgevoerd op de huidige TaskScheduler. |
| RunSynchronously(TaskScheduler) |
Hiermee wordt de Task synchrone uitvoering uitgevoerd op de TaskScheduler opgegeven. |
| Start() |
Hiermee start u de Taskplanning voor uitvoering naar de huidige TaskScheduler. |
| Start(TaskScheduler) |
Hiermee start u de Task, planning voor uitvoering naar de opgegeven TaskScheduler. |
| ToString() |
Retourneert een tekenreeks die het huidige object vertegenwoordigt. (Overgenomen van Object) |
| Wait() |
Wacht totdat de Task uitvoering is voltooid. |
| Wait(CancellationToken) |
Wacht totdat de Task uitvoering is voltooid. De wachttijd wordt beëindigd als een annuleringstoken wordt geannuleerd voordat de taak is voltooid. |
| Wait(Int32, CancellationToken) |
Wacht totdat de Task uitvoering is voltooid. De wachttijd wordt beëindigd als een time-outinterval is verstreken of een annuleringstoken wordt geannuleerd voordat de taak is voltooid. |
| Wait(Int32) |
Wacht totdat de Task uitvoering binnen een opgegeven aantal milliseconden is voltooid. |
| Wait(TimeSpan, CancellationToken) |
Wacht totdat de Task uitvoering is voltooid. |
| Wait(TimeSpan) |
Wacht totdat de Task uitvoering binnen een opgegeven tijdsinterval is voltooid. |
| WaitAll(IEnumerable<Task>, CancellationToken) |
Wacht tot alle opgegeven Task objecten de uitvoering hebben voltooid, tenzij de wachttijd is geannuleerd. |
| WaitAll(ReadOnlySpan<Task>) |
Wacht tot alle opgegeven Task objecten de uitvoering hebben voltooid. |
| WaitAll(Task[], CancellationToken) |
Wacht tot alle opgegeven Task objecten de uitvoering hebben voltooid, tenzij de wachttijd is geannuleerd. |
| WaitAll(Task[], Int32, CancellationToken) |
Wacht totdat alle opgegeven Task objecten de uitvoering binnen een opgegeven aantal milliseconden hebben voltooid of totdat de wachttijd is geannuleerd. |
| WaitAll(Task[], Int32) |
Wacht tot alle opgegeven Task objecten de uitvoering binnen een opgegeven aantal milliseconden hebben voltooid. |
| WaitAll(Task[], TimeSpan) |
Wacht tot alle opgegeven geannuleerde Task objecten binnen een opgegeven tijdsinterval de uitvoering hebben voltooid. |
| WaitAll(Task[]) |
Wacht tot alle opgegeven Task objecten de uitvoering hebben voltooid. |
| WaitAny(Task[], CancellationToken) |
Wacht tot een van de opgegeven Task objecten de uitvoering heeft voltooid, tenzij de wachttijd is geannuleerd. |
| WaitAny(Task[], Int32, CancellationToken) |
Wacht tot een van de opgegeven Task objecten de uitvoering binnen een opgegeven aantal milliseconden heeft voltooid of totdat een annuleringstoken wordt geannuleerd. |
| WaitAny(Task[], Int32) |
Wacht tot een van de opgegeven Task objecten de uitvoering binnen een opgegeven aantal milliseconden heeft voltooid. |
| WaitAny(Task[], TimeSpan) |
Wacht tot een van de opgegeven Task objecten de uitvoering binnen een opgegeven tijdsinterval heeft voltooid. |
| WaitAny(Task[]) |
Wacht tot een van de opgegeven Task objecten de uitvoering heeft voltooid. |
| WaitAsync(CancellationToken) |
Hiermee haalt u een Task bewerking op die wordt voltooid wanneer dit Task is voltooid of wanneer de opgegeven CancellationToken annulering heeft aangevraagd. |
| WaitAsync(TimeSpan, CancellationToken) |
Hiermee haalt u een Task bewerking op die wordt voltooid wanneer dit Task is voltooid, wanneer de opgegeven time-out verloopt of wanneer de opgegeven CancellationToken annulering heeft aangevraagd. |
| WaitAsync(TimeSpan, TimeProvider, CancellationToken) |
Hiermee haalt u een Task bewerking op die wordt voltooid wanneer dit Task is voltooid, wanneer de opgegeven time-out verloopt of wanneer de opgegeven CancellationToken annulering heeft aangevraagd. |
| WaitAsync(TimeSpan, TimeProvider) |
Hiermee wordt een Task bewerking uitgevoerd wanneer dit Task is voltooid of wanneer de opgegeven time-out verloopt. |
| WaitAsync(TimeSpan) |
Hiermee wordt een Task bewerking uitgevoerd wanneer dit Task is voltooid of wanneer de opgegeven time-out verloopt. |
| WhenAll(IEnumerable<Task>) |
Hiermee maakt u een taak die wordt voltooid wanneer alle Task objecten in een enumerable verzameling zijn voltooid. |
| WhenAll(ReadOnlySpan<Task>) |
Hiermee maakt u een taak die wordt voltooid wanneer alle opgegeven taken zijn voltooid. |
| WhenAll(Task[]) |
Hiermee maakt u een taak die wordt voltooid wanneer alle Task objecten in een matrix zijn voltooid. |
| WhenAll<TResult>(IEnumerable<Task<TResult>>) |
Hiermee maakt u een taak die wordt voltooid wanneer alle Task<TResult> objecten in een enumerable verzameling zijn voltooid. |
| WhenAll<TResult>(ReadOnlySpan<Task<TResult>>) |
Hiermee maakt u een taak die wordt voltooid wanneer alle opgegeven taken zijn voltooid. |
| WhenAll<TResult>(Task<TResult>[]) |
Hiermee maakt u een taak die wordt voltooid wanneer alle Task<TResult> objecten in een matrix zijn voltooid. |
| WhenAny(IEnumerable<Task>) |
Hiermee maakt u een taak die wordt voltooid wanneer een van de opgegeven taken is voltooid. |
| WhenAny(ReadOnlySpan<Task>) |
Hiermee maakt u een taak die wordt voltooid wanneer een van de opgegeven taken is voltooid. |
| WhenAny(Task, Task) |
Hiermee maakt u een taak die wordt voltooid wanneer een van de opgegeven taken is voltooid. |
| WhenAny(Task[]) |
Hiermee maakt u een taak die wordt voltooid wanneer een van de opgegeven taken is voltooid. |
| WhenAny<TResult>(IEnumerable<Task<TResult>>) |
Hiermee maakt u een taak die wordt voltooid wanneer een van de opgegeven taken is voltooid. |
| WhenAny<TResult>(ReadOnlySpan<Task<TResult>>) |
Hiermee maakt u een taak die wordt voltooid wanneer een van de opgegeven taken is voltooid. |
| WhenAny<TResult>(Task<TResult>, Task<TResult>) |
Hiermee maakt u een taak die wordt voltooid wanneer een van de opgegeven taken is voltooid. |
| WhenAny<TResult>(Task<TResult>[]) |
Hiermee maakt u een taak die wordt voltooid wanneer een van de opgegeven taken is voltooid. |
| WhenEach(IEnumerable<Task>) |
Hiermee maakt u een IAsyncEnumerable<T> taak die de opgegeven taken oplevert wanneer deze taken zijn voltooid. |
| WhenEach(ReadOnlySpan<Task>) |
Hiermee maakt u een IAsyncEnumerable<T> taak die de opgegeven taken oplevert wanneer deze taken zijn voltooid. |
| WhenEach(Task[]) |
Hiermee maakt u een IAsyncEnumerable<T> taak die de opgegeven taken oplevert wanneer deze taken zijn voltooid. |
| WhenEach<TResult>(IEnumerable<Task<TResult>>) |
Hiermee maakt u een IAsyncEnumerable<T> taak die de opgegeven taken oplevert wanneer deze taken zijn voltooid. |
| WhenEach<TResult>(ReadOnlySpan<Task<TResult>>) |
Hiermee maakt u een IAsyncEnumerable<T> taak die de opgegeven taken oplevert wanneer deze taken zijn voltooid. |
| WhenEach<TResult>(Task<TResult>[]) |
Hiermee maakt u een IAsyncEnumerable<T> taak die de opgegeven taken oplevert wanneer deze taken zijn voltooid. |
| Yield() |
Hiermee maakt u een te wachten taak die asynchroon terugbrengt naar de huidige context wanneer deze wordt verwacht. |
Expliciete interface-implementaties
| Name | Description |
|---|---|
| IAsyncResult.AsyncWaitHandle |
Hiermee haalt u een WaitHandle op die kan worden gebruikt om te wachten totdat de taak is voltooid. |
| IAsyncResult.CompletedSynchronously |
Hiermee wordt aangegeven of de bewerking synchroon is voltooid. |
Extensiemethoden
| Name | Description |
|---|---|
| AsAsyncAction(Task) |
Retourneert een Windows Runtime asynchrone actie die een gestarte taak vertegenwoordigt. |
| DispatcherOperationWait(Task, TimeSpan) |
Wacht tot de opgegeven tijdsduur is DispatcherOperation voltooid. |
| DispatcherOperationWait(Task) |
Wacht voor onbepaalde tijd totdat de onderliggende DispatcherOperation waarde is voltooid. |
| IsDispatcherOperationTask(Task) |
Retourneert een waarde die aangeeft of dit Task is gekoppeld aan een DispatcherOperation. |
Van toepassing op
Veiligheid thread
Alle leden van, met uitzondering TaskvanDispose(), zijn thread-veilig en kunnen gelijktijdig worden gebruikt vanuit meerdere threads.
