Taken koppelen met behulp van vervolgtaken
Bij asynchrone programmering is het gebruikelijk dat een asynchrone bewerking een tweede bewerking aanroept bij voltooiing. Met vervolgbewerkingen kunnen onderliggende bewerkingen de resultaten van de eerste bewerking gebruiken. Traditioneel zijn vervolgen gedaan met behulp van callback-methoden. In de Task Parallel Library (TPL) wordt dezelfde functionaliteit geboden door vervolgtaken. Een vervolgtaak (ook wel een vervolg genoemd) is een asynchrone taak die wordt aangeroepen door een andere taak, ook wel de antecedent genoemd, wanneer de antecedent is voltooid.
Voortzettingen zijn relatief eenvoudig te gebruiken, maar zijn niettemin krachtig en flexibel. U kunt bijvoorbeeld:
- Geef gegevens van de antecedent door aan de voortzetting.
- Geef de precieze voorwaarden op waaronder de voortzetting wordt aangeroepen of niet wordt aangeroepen.
- Annuleer een vervolg voordat deze wordt gestart of coöperatief terwijl deze wordt uitgevoerd.
- Geef hints over hoe de voortzetting moet worden gepland.
- Roep meerdere vervolgen aan van dezelfde antecedent.
- Roep één vervolg aan wanneer alle of een van meerdere antecedenten is voltooid.
- Ketenvervolgingen één na elkaar tot elke willekeurige lengte.
- Gebruik een vervolg voor het afhandelen van uitzonderingen die zijn gegenereerd door de antecedent.
Over vervolgen
Een vervolg is een taak die in de WaitingForActivation status is gemaakt. Deze wordt automatisch geactiveerd wanneer de antecedente taak of taken zijn voltooid. Als u een vervolg in de gebruikerscode aanroept Task.Start , wordt er een System.InvalidOperationException uitzondering gegenereerd.
Een vervolg is zelf een Task en blokkeert niet de thread waarop deze is gestart. Roep de Task.Wait methode aan die moet worden geblokkeerd totdat de vervolgtaak is voltooid.
Een vervolg maken voor één antecedent
U maakt een vervolg dat wordt uitgevoerd wanneer de antecedent is voltooid door de methode aan te Task.ContinueWith roepen. In het volgende voorbeeld ziet u het basispatroon (voor duidelijkheid wordt de verwerking van uitzonderingen weggelaten). Er wordt een antecedenttaak taskA uitgevoerd die een DayOfWeek object retourneert dat de naam van de huidige dag van de week aangeeft. Wanneer taskA dit is voltooid, vertegenwoordigt de antecedent resultaten ervan in de ContinueWith vervolgmethode. Het resultaat van de antecedent-taak wordt naar de console geschreven.
using System;
using System.Threading.Tasks;
public class SimpleExample
{
public static async Task Main()
{
// Declare, assign, and start the antecedent task.
Task<DayOfWeek> taskA = Task.Run(() => DateTime.Today.DayOfWeek);
// Execute the continuation when the antecedent finishes.
await taskA.ContinueWith(antecedent => Console.WriteLine($"Today is {antecedent.Result}."));
}
}
// The example displays the following output:
// Today is Monday.
Imports System.Threading.Tasks
Module Example
Public Sub Main()
' Execute the antecedent.
Dim taskA As Task(Of DayOfWeek) = Task.Run(Function() DateTime.Today.DayOfWeek)
' Execute the continuation when the antecedent finishes.
Dim continuation As Task = taskA.ContinueWith(Sub(antecedent)
Console.WriteLine("Today is {0}.", antecedent.Result)
End Sub)
continuation.Wait()
End Sub
End Module
' The example displays output like the following output:
' Today is Monday.
Een vervolg maken voor meerdere antecedenten
U kunt ook een vervolg maken die wordt uitgevoerd wanneer een of alle taken zijn voltooid. Als u een vervolg wilt uitvoeren wanneer alle antecedent-taken zijn voltooid, kunt u de statische methode (Shared in Visual Basic) Task.WhenAll of de instantiemethode TaskFactory.ContinueWhenAll aanroepen. Als u een vervolg wilt uitvoeren wanneer een van de antecedent-taken is voltooid, kunt u de statische methode (Shared in Visual Basic) Task.WhenAny of de instantiemethode TaskFactory.ContinueWhenAny aanroepen.
Aanroepen naar de Task.WhenAll gespreks- en Task.WhenAny overbelasting blokkeren de aanroepende thread niet. Meestal roept u echter alle behalve de Task.WhenAll(IEnumerable<Task>) en Task.WhenAll(Task[]) methoden aan om de geretourneerde eigenschap op te halen, waardoor de aanroepende Task<TResult>.Result thread wel wordt geblokkeerd.
In het volgende voorbeeld wordt de Task.WhenAll(IEnumerable<Task>) methode aangeroepen om een vervolgtaak te maken die de resultaten van de 10 antecedent-taken weergeeft. Elke antecedente taak kwadrateert een indexwaarde die varieert van één tot 10. Als de antecedenten zijn voltooid (hun Task.Status eigenschap is TaskStatus.RanToCompletion), is de Task<TResult>.Result eigenschap van de voortzetting een matrix van de Task<TResult>.Result waarden die door elke antecedent worden geretourneerd. In het voorbeeld worden ze opgeteld om de som van kwadraten voor alle getallen tussen één en 10 te berekenen:
using System.Collections.Generic;
using System;
using System.Threading.Tasks;
public class WhenAllExample
{
public static async Task Main()
{
var tasks = new List<Task<int>>();
for (int ctr = 1; ctr <= 10; ctr++)
{
int baseValue = ctr;
tasks.Add(Task.Factory.StartNew(b => (int)b! * (int)b, baseValue));
}
var results = await Task.WhenAll(tasks);
int sum = 0;
for (int ctr = 0; ctr <= results.Length - 1; ctr++)
{
var result = results[ctr];
Console.Write($"{result} {((ctr == results.Length - 1) ? "=" : "+")} ");
sum += result;
}
Console.WriteLine(sum);
}
}
// The example displays the similar output:
// 1 + 4 + 9 + 16 + 25 + 36 + 49 + 64 + 81 + 100 = 385
Imports System.Collections.Generic
Imports System.Threading.Tasks
Module Example
Public Sub Main()
Dim tasks As New List(Of Task(Of Integer))()
For ctr As Integer = 1 To 10
Dim baseValue As Integer = ctr
tasks.Add(Task.Factory.StartNew(Function(b)
Dim i As Integer = CInt(b)
Return i * i
End Function, baseValue))
Next
Dim continuation = Task.WhenAll(tasks)
Dim sum As Long = 0
For ctr As Integer = 0 To continuation.Result.Length - 1
Console.Write("{0} {1} ", continuation.Result(ctr),
If(ctr = continuation.Result.Length - 1, "=", "+"))
sum += continuation.Result(ctr)
Next
Console.WriteLine(sum)
End Sub
End Module
' The example displays the following output:
' 1 + 4 + 9 + 16 + 25 + 36 + 49 + 64 + 81 + 100 = 385
Vervolgopties
Wanneer u een vervolgbewerking met één taak maakt, kunt u een overbelasting gebruiken die een ContinueWithSystem.Threading.Tasks.TaskContinuationOptions opsommingswaarde gebruikt om de voorwaarden op te geven waaronder de voortzetting begint. U kunt bijvoorbeeld opgeven dat de voortzetting alleen moet worden uitgevoerd als de antecedent is voltooid of alleen als deze is voltooid in een foutieve status. Als de voorwaarde niet waar is wanneer de antecedent klaar is om de voortzetting aan te roepen, gaat de voortzetting rechtstreeks naar de TaskStatus.Canceled status en kan deze later niet meer worden gestart.
Veel vervolgmethoden voor meerdere taken, zoals overbelastingen van de TaskFactory.ContinueWhenAll methode, bevatten ook een System.Threading.Tasks.TaskContinuationOptions parameter. Alleen een subset van alle System.Threading.Tasks.TaskContinuationOptions opsommingsleden is echter geldig. U kunt waarden opgeven System.Threading.Tasks.TaskContinuationOptions die tegenhangers hebben in de System.Threading.Tasks.TaskCreationOptions opsomming, zoals TaskContinuationOptions.AttachedToParent, TaskContinuationOptions.LongRunningen TaskContinuationOptions.PreferFairness. Als u een van de NotOn of OnlyOn opties met een vervolg voor meerdere taken opgeeft, wordt er tijdens de uitvoering een ArgumentOutOfRangeException uitzondering gegenereerd.
Zie het TaskContinuationOptions artikel voor meer informatie over opties voor taakvervolging.
Gegevens doorgeven aan een vervolg
Met Task.ContinueWith de methode wordt een verwijzing naar de antecedent als argument doorgegeven aan de gemachtigde van de gebruiker van de voortzetting. Als de antecedent een System.Threading.Tasks.Task<TResult> object is en de taak is uitgevoerd totdat deze is voltooid, heeft de voortzetting toegang tot de Task<TResult>.Result eigenschap van de taak.
De Task<TResult>.Result eigenschap wordt geblokkeerd totdat de taak is voltooid. Als de taak echter is geannuleerd of defect is, wordt er een AggregateException uitzondering gegenereerd bij een poging om toegang te krijgen tot de Result eigenschap. U kunt dit probleem voorkomen met behulp van de OnlyOnRanToCompletion optie, zoals wordt weergegeven in het volgende voorbeeld:
using System;
using System.Threading.Tasks;
public class ResultExample
{
public static async Task Main()
{
var task = Task.Run(
() =>
{
DateTime date = DateTime.Now;
return date.Hour > 17
? "evening"
: date.Hour > 12
? "afternoon"
: "morning";
});
await task.ContinueWith(
antecedent =>
{
Console.WriteLine($"Good {antecedent.Result}!");
Console.WriteLine($"And how are you this fine {antecedent.Result}?");
}, TaskContinuationOptions.OnlyOnRanToCompletion);
}
}
// The example displays the similar output:
// Good afternoon!
// And how are you this fine afternoon?
Imports System.Threading.Tasks
Module Example
Public Sub Main()
Dim t = Task.Run(Function()
Dim dat As DateTime = DateTime.Now
If dat = DateTime.MinValue Then
Throw New ArgumentException("The clock is not working.")
End If
If dat.Hour > 17 Then
Return "evening"
Else If dat.Hour > 12 Then
Return "afternoon"
Else
Return "morning"
End If
End Function)
Dim c = t.ContinueWith(Sub(antecedent)
Console.WriteLine("Good {0}!",
antecedent.Result)
Console.WriteLine("And how are you this fine {0}?",
antecedent.Result)
End Sub, TaskContinuationOptions.OnlyOnRanToCompletion)
c.Wait()
End Sub
End Module
' The example displays output like the following:
' Good afternoon!
' And how are you this fine afternoon?
Als u wilt dat de voortzetting wordt uitgevoerd, zelfs als de antecedent niet tot een geslaagde voltooiing is uitgevoerd, moet u de uitzondering beschermen. Eén benadering is het testen van de Task.Status eigenschap van de antecedent en probeert alleen toegang te krijgen tot de Result eigenschap als de status niet Faulted of Canceled. U kunt ook de Exception eigenschap van de antecedent onderzoeken. Zie Uitzonderingsafhandeling voor meer informatie. In het volgende voorbeeld wordt het voorgaande voorbeeld alleen gewijzigd om alleen toegang te krijgen tot de eigenschap van Task<TResult>.Result antecedent als de status is TaskStatus.RanToCompletion:
using System;
using System.Threading.Tasks;
public class ResultTwoExample
{
public static async Task Main() =>
await Task.Run(
() =>
{
DateTime date = DateTime.Now;
return date.Hour > 17
? "evening"
: date.Hour > 12
? "afternoon"
: "morning";
})
.ContinueWith(
antecedent =>
{
if (antecedent.Status == TaskStatus.RanToCompletion)
{
Console.WriteLine($"Good {antecedent.Result}!");
Console.WriteLine($"And how are you this fine {antecedent.Result}?");
}
else if (antecedent.Status == TaskStatus.Faulted)
{
Console.WriteLine(antecedent.Exception!.GetBaseException().Message);
}
});
}
// The example displays output like the following:
// Good afternoon!
// And how are you this fine afternoon?
Imports System.Threading.Tasks
Module Example
Public Sub Main()
Dim t = Task.Run(Function()
Dim dat As DateTime = DateTime.Now
If dat = DateTime.MinValue Then
Throw New ArgumentException("The clock is not working.")
End If
If dat.Hour > 17 Then
Return "evening"
Else If dat.Hour > 12 Then
Return "afternoon"
Else
Return "morning"
End If
End Function)
Dim c = t.ContinueWith(Sub(antecedent)
If t.Status = TaskStatus.RanToCompletion Then
Console.WriteLine("Good {0}!",
antecedent.Result)
Console.WriteLine("And how are you this fine {0}?",
antecedent.Result)
Else If t.Status = TaskStatus.Faulted Then
Console.WriteLine(t.Exception.GetBaseException().Message)
End If
End Sub)
End Sub
End Module
' The example displays output like the following:
' Good afternoon!
' And how are you this fine afternoon?
Een vervolg annuleren
De Task.Status eigenschap van een vervolg is ingesteld op TaskStatus.Canceled in de volgende situaties:
Er wordt een OperationCanceledException uitzondering gegenereerd als reactie op een annuleringsaanvraag. Net als bij elke taak, als de uitzondering hetzelfde token bevat dat aan de voortzetting is doorgegeven, wordt deze beschouwd als een bevestiging van coöperatieve annulering.
De voortzetting wordt doorgegeven aan een System.Threading.CancellationToken waarvan IsCancellationRequested de eigenschap is
true. In dit geval wordt de voortzetting niet gestart en wordt deze overgestapt op de TaskStatus.Canceled status.De voortzetting wordt nooit uitgevoerd omdat niet is voldaan aan de voorwaarde die is ingesteld door het TaskContinuationOptions argument. Als een antecedent bijvoorbeeld een TaskStatus.Faulted status krijgt, wordt de voortzetting die is doorgegeven, TaskContinuationOptions.NotOnFaulted niet uitgevoerd, maar wordt deze overgegaan naar de Canceled status.
Als een taak en de voortzetting twee delen van dezelfde logische bewerking vertegenwoordigen, kunt u hetzelfde annuleringstoken doorgeven aan beide taken, zoals wordt weergegeven in het volgende voorbeeld. Het bestaat uit een antecedent die een lijst met gehele getallen genereert die deelbaar zijn door 33, die het doorgeeft aan de voortzetting. In de vervolgweergave wordt de lijst weergegeven. Zowel de antecedent als de voortzetting onderbreken regelmatig voor willekeurige intervallen. Daarnaast wordt een System.Threading.Timer object gebruikt om de Elapsed methode uit te voeren na een time-outinterval van vijf seconden. In dit voorbeeld wordt de CancellationTokenSource.Cancel methode aangeroepen, waardoor de momenteel uitgevoerde taak de CancellationToken.ThrowIfCancellationRequested methode aanroept. Of de CancellationTokenSource.Cancel methode wordt aangeroepen wanneer de antecedent of de voortzetting wordt uitgevoerd, is afhankelijk van de duur van de willekeurig gegenereerde pauzes. Als de antecedent wordt geannuleerd, wordt de voortzetting niet gestart. Als de antecedent niet wordt geannuleerd, kan het token nog steeds worden gebruikt om de voortzetting te annuleren.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
public class CancellationExample
{
static readonly Random s_random = new Random((int)DateTime.Now.Ticks);
public static async Task Main()
{
using var cts = new CancellationTokenSource();
CancellationToken token = cts.Token;
var timer = new Timer(Elapsed, cts, 5000, Timeout.Infinite);
var task = Task.Run(
async () =>
{
var product33 = new List<int>();
for (int index = 1; index < short.MaxValue; index++)
{
if (token.IsCancellationRequested)
{
Console.WriteLine("\nCancellation requested in antecedent...\n");
token.ThrowIfCancellationRequested();
}
if (index % 2000 == 0)
{
int delay = s_random.Next(16, 501);
await Task.Delay(delay);
}
if (index % 33 == 0)
{
product33.Add(index);
}
}
return product33.ToArray();
}, token);
Task<double> continuation = task.ContinueWith(
async antecedent =>
{
Console.WriteLine("Multiples of 33:\n");
int[] array = antecedent.Result;
for (int index = 0; index < array.Length; index++)
{
if (token.IsCancellationRequested)
{
Console.WriteLine("\nCancellation requested in continuation...\n");
token.ThrowIfCancellationRequested();
}
if (index % 100 == 0)
{
int delay = s_random.Next(16, 251);
await Task.Delay(delay);
}
Console.Write($"{array[index]:N0}{(index != array.Length - 1 ? ", " : "")}");
if (Console.CursorLeft >= 74)
{
Console.WriteLine();
}
}
Console.WriteLine();
return array.Average();
}, token).Unwrap();
try
{
await task;
double result = await continuation;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
Console.WriteLine("\nAntecedent Status: {0}", task.Status);
Console.WriteLine("Continuation Status: {0}", continuation.Status);
}
static void Elapsed(object? state)
{
if (state is CancellationTokenSource cts)
{
cts.Cancel();
Console.WriteLine("\nCancellation request issued...\n");
}
}
}
// The example displays the similar output:
// Multiples of 33:
//
// 33, 66, 99, 132, 165, 198, 231, 264, 297, 330, 363, 396, 429, 462, 495, 528,
// 561, 594, 627, 660, 693, 726, 759, 792, 825, 858, 891, 924, 957, 990, 1,023,
// 1,056, 1,089, 1,122, 1,155, 1,188, 1,221, 1,254, 1,287, 1,320, 1,353, 1,386,
// 1,419, 1,452, 1,485, 1,518, 1,551, 1,584, 1,617, 1,650, 1,683, 1,716, 1,749,
// 1,782, 1,815, 1,848, 1,881, 1,914, 1,947, 1,980, 2,013, 2,046, 2,079, 2,112,
// 2,145, 2,178, 2,211, 2,244, 2,277, 2,310, 2,343, 2,376, 2,409, 2,442, 2,475,
// 2,508, 2,541, 2,574, 2,607, 2,640, 2,673, 2,706, 2,739, 2,772, 2,805, 2,838,
// 2,871, 2,904, 2,937, 2,970, 3,003, 3,036, 3,069, 3,102, 3,135, 3,168, 3,201,
// 3,234, 3,267, 3,300, 3,333, 3,366, 3,399, 3,432, 3,465, 3,498, 3,531, 3,564,
// 3,597, 3,630, 3,663, 3,696, 3,729, 3,762, 3,795, 3,828, 3,861, 3,894, 3,927,
// 3,960, 3,993, 4,026, 4,059, 4,092, 4,125, 4,158, 4,191, 4,224, 4,257, 4,290,
// 4,323, 4,356, 4,389, 4,422, 4,455, 4,488, 4,521, 4,554, 4,587, 4,620, 4,653,
// 4,686, 4,719, 4,752, 4,785, 4,818, 4,851, 4,884, 4,917, 4,950, 4,983, 5,016,
// 5,049, 5,082, 5,115, 5,148, 5,181, 5,214, 5,247, 5,280, 5,313, 5,346, 5,379,
// 5,412, 5,445, 5,478, 5,511, 5,544, 5,577, 5,610, 5,643, 5,676, 5,709, 5,742,
// Cancellation request issued...
//
// 5,775,
// Cancellation requested in continuation...
//
// The operation was canceled.
//
// Antecedent Status: RanToCompletion
// Continuation Status: Canceled
Imports System.Collections.Generic
Imports System.Threading
Imports System.Threading.Tasks
Module Example
Public Sub Main()
Dim rnd As New Random()
Dim lockObj As New Object()
Dim cts As New CancellationTokenSource()
Dim token As CancellationToken = cts.Token
Dim timer As New Timer(AddressOf Elapsed, cts, 5000, Timeout.Infinite)
Dim t = Task.Run(Function()
Dim product33 As New List(Of Integer)()
For ctr As Integer = 1 To Int16.MaxValue
' Check for cancellation.
If token.IsCancellationRequested Then
Console.WriteLine("\nCancellation requested in antecedent...\n")
token.ThrowIfCancellationRequested()
End If
' Introduce a delay.
If ctr Mod 2000 = 0 Then
Dim delay As Integer
SyncLock lockObj
delay = rnd.Next(16, 501)
End SyncLock
Thread.Sleep(delay)
End If
' Determine if this is a multiple of 33.
If ctr Mod 33 = 0 Then product33.Add(ctr)
Next
Return product33.ToArray()
End Function, token)
Dim continuation = t.ContinueWith(Sub(antecedent)
Console.WriteLine("Multiples of 33:" + vbCrLf)
Dim arr = antecedent.Result
For ctr As Integer = 0 To arr.Length - 1
If token.IsCancellationRequested Then
Console.WriteLine("{0}Cancellation requested in continuation...{0}",
vbCrLf)
token.ThrowIfCancellationRequested()
End If
If ctr Mod 100 = 0 Then
Dim delay As Integer
SyncLock lockObj
delay = rnd.Next(16, 251)
End SyncLock
Thread.Sleep(delay)
End If
Console.Write("{0:N0}{1}", arr(ctr),
If(ctr <> arr.Length - 1, ", ", ""))
If Console.CursorLeft >= 74 Then Console.WriteLine()
Next
Console.WriteLine()
End Sub, token)
Try
continuation.Wait()
Catch e As AggregateException
For Each ie In e.InnerExceptions
Console.WriteLine("{0}: {1}", ie.GetType().Name,
ie.Message)
Next
Finally
cts.Dispose()
End Try
Console.WriteLine(vbCrLf + "Antecedent Status: {0}", t.Status)
Console.WriteLine("Continuation Status: {0}", continuation.Status)
End Sub
Private Sub Elapsed(state As Object)
Dim cts As CancellationTokenSource = TryCast(state, CancellationTokenSource)
If cts Is Nothing Then return
cts.Cancel()
Console.WriteLine("{0}Cancellation request issued...{0}", vbCrLf)
End Sub
End Module
' The example displays output like the following:
' Multiples of 33:
'
' 33, 66, 99, 132, 165, 198, 231, 264, 297, 330, 363, 396, 429, 462, 495, 528,
' 561, 594, 627, 660, 693, 726, 759, 792, 825, 858, 891, 924, 957, 990, 1,023,
' 1,056, 1,089, 1,122, 1,155, 1,188, 1,221, 1,254, 1,287, 1,320, 1,353, 1,386,
' 1,419, 1,452, 1,485, 1,518, 1,551, 1,584, 1,617, 1,650, 1,683, 1,716, 1,749,
' 1,782, 1,815, 1,848, 1,881, 1,914, 1,947, 1,980, 2,013, 2,046, 2,079, 2,112,
' 2,145, 2,178, 2,211, 2,244, 2,277, 2,310, 2,343, 2,376, 2,409, 2,442, 2,475,
' 2,508, 2,541, 2,574, 2,607, 2,640, 2,673, 2,706, 2,739, 2,772, 2,805, 2,838,
' 2,871, 2,904, 2,937, 2,970, 3,003, 3,036, 3,069, 3,102, 3,135, 3,168, 3,201,
' 3,234, 3,267, 3,300, 3,333, 3,366, 3,399, 3,432, 3,465, 3,498, 3,531, 3,564,
' 3,597, 3,630, 3,663, 3,696, 3,729, 3,762, 3,795, 3,828, 3,861, 3,894, 3,927,
' 3,960, 3,993, 4,026, 4,059, 4,092, 4,125, 4,158, 4,191, 4,224, 4,257, 4,290,
' 4,323, 4,356, 4,389, 4,422, 4,455, 4,488, 4,521, 4,554, 4,587, 4,620, 4,653,
' 4,686, 4,719, 4,752, 4,785, 4,818, 4,851, 4,884, 4,917, 4,950, 4,983, 5,016,
' 5,049, 5,082, 5,115, 5,148, 5,181, 5,214, 5,247, 5,280, 5,313, 5,346, 5,379,
' 5,412, 5,445, 5,478, 5,511, 5,544, 5,577, 5,610, 5,643, 5,676, 5,709, 5,742,
' 5,775, 5,808, 5,841, 5,874, 5,907, 5,940, 5,973, 6,006, 6,039, 6,072, 6,105,
' 6,138, 6,171, 6,204, 6,237, 6,270, 6,303, 6,336, 6,369, 6,402, 6,435, 6,468,
' 6,501, 6,534, 6,567, 6,600, 6,633, 6,666, 6,699, 6,732, 6,765, 6,798, 6,831,
' 6,864, 6,897, 6,930, 6,963, 6,996, 7,029, 7,062, 7,095, 7,128, 7,161, 7,194,
' 7,227, 7,260, 7,293, 7,326, 7,359, 7,392, 7,425, 7,458, 7,491, 7,524, 7,557,
' 7,590, 7,623, 7,656, 7,689, 7,722, 7,755, 7,788, 7,821, 7,854, 7,887, 7,920,
' 7,953, 7,986, 8,019, 8,052, 8,085, 8,118, 8,151, 8,184, 8,217, 8,250, 8,283,
' 8,316, 8,349, 8,382, 8,415, 8,448, 8,481, 8,514, 8,547, 8,580, 8,613, 8,646,
' 8,679, 8,712, 8,745, 8,778, 8,811, 8,844, 8,877, 8,910, 8,943, 8,976, 9,009,
' 9,042, 9,075, 9,108, 9,141, 9,174, 9,207, 9,240, 9,273, 9,306, 9,339, 9,372,
' 9,405, 9,438, 9,471, 9,504, 9,537, 9,570, 9,603, 9,636, 9,669, 9,702, 9,735,
' 9,768, 9,801, 9,834, 9,867, 9,900, 9,933, 9,966, 9,999, 10,032, 10,065, 10,098,
' 10,131, 10,164, 10,197, 10,230, 10,263, 10,296, 10,329, 10,362, 10,395, 10,428,
' 10,461, 10,494, 10,527, 10,560, 10,593, 10,626, 10,659, 10,692, 10,725, 10,758,
' 10,791, 10,824, 10,857, 10,890, 10,923, 10,956, 10,989, 11,022, 11,055, 11,088,
' 11,121, 11,154, 11,187, 11,220, 11,253, 11,286, 11,319, 11,352, 11,385, 11,418,
' 11,451, 11,484, 11,517, 11,550, 11,583, 11,616, 11,649, 11,682, 11,715, 11,748,
' 11,781, 11,814, 11,847, 11,880, 11,913, 11,946, 11,979, 12,012, 12,045, 12,078,
' 12,111, 12,144, 12,177, 12,210, 12,243, 12,276, 12,309, 12,342, 12,375, 12,408,
' 12,441, 12,474, 12,507, 12,540, 12,573, 12,606, 12,639, 12,672, 12,705, 12,738,
' 12,771, 12,804, 12,837, 12,870, 12,903, 12,936, 12,969, 13,002, 13,035, 13,068,
' 13,101, 13,134, 13,167, 13,200, 13,233, 13,266,
' Cancellation requested in continuation...
'
'
' Cancellation request issued...
'
' TaskCanceledException: A task was canceled.
'
' Antecedent Status: RanToCompletion
' Continuation Status: Canceled
U kunt ook voorkomen dat een vervolg wordt uitgevoerd als de antecedent wordt geannuleerd zonder de voortzetting van een annuleringstoken op te geven. Geef het token op door de TaskContinuationOptions.NotOnCanceled optie op te geven wanneer u de voortzetting maakt, zoals wordt weergegeven in het volgende voorbeeld:
using System;
using System.Threading;
using System.Threading.Tasks;
public class CancellationTwoExample
{
public static async Task Main()
{
using var cts = new CancellationTokenSource();
CancellationToken token = cts.Token;
cts.Cancel();
var task = Task.FromCanceled(token);
Task continuation =
task.ContinueWith(
antecedent => Console.WriteLine("The continuation is running."),
TaskContinuationOptions.NotOnCanceled);
try
{
await task;
}
catch (Exception ex)
{
Console.WriteLine($"{ex.GetType().Name}: {ex.Message}");
Console.WriteLine();
}
Console.WriteLine($"Task {task.Id}: {task.Status:G}");
Console.WriteLine($"Task {continuation.Id}: {continuation.Status:G}");
}
}
// The example displays the similar output:
// TaskCanceledException: A task was canceled.
//
// Task 1: Canceled
// Task 2: Canceled
Imports System.Threading
Imports System.Threading.Tasks
Module Example
Public Sub Main()
Dim cts As New CancellationTokenSource()
Dim token As CancellationToken = cts.Token
cts.Cancel()
Dim t As Task = Task.FromCanceled(token)
Dim continuation As Task = t.ContinueWith(Sub(antecedent)
Console.WriteLine("The continuation is running.")
End Sub, TaskContinuationOptions.NotOnCanceled)
Try
t.Wait()
Catch e As AggregateException
For Each ie In e.InnerExceptions
Console.WriteLine("{0}: {1}", ie.GetType().Name, ie.Message)
Next
Console.WriteLine()
Finally
cts.Dispose()
End Try
Console.WriteLine("Task {0}: {1:G}", t.Id, t.Status)
Console.WriteLine("Task {0}: {1:G}", continuation.Id,
continuation.Status)
End Sub
End Module
' The example displays the following output:
' TaskCanceledException: A task was canceled.
'
' Task 1: Canceled
' Task 2: Canceled
Nadat een voortzetting de Canceled status heeft, kan dit van invloed zijn op vervolgen die volgen, afhankelijk van de TaskContinuationOptions opgegeven voor deze vervolgen.
Vervolgen die worden verwijderd, worden niet gestart.
Vervolgen en onderliggende taken
Een vervolg wordt pas uitgevoerd als de antecedent en alle gekoppelde onderliggende taken zijn voltooid. Een vervolg wacht niet tot de losgekoppelde onderliggende taken zijn voltooid. In de volgende twee voorbeelden ziet u onderliggende taken die zijn gekoppeld aan en losgekoppeld van een antecedent waarmee een vervolg wordt gemaakt. In het volgende voorbeeld wordt de vervolgbewerking pas uitgevoerd nadat alle onderliggende taken zijn voltooid en meerdere uitvoeringen van het voorbeeld elke keer identieke uitvoer produceren. In het voorbeeld wordt de antecedent gestart door de TaskFactory.StartNew methode aan te roepen, omdat met de methode standaard een bovenliggende taak wordt gemaakt waarvan de Task.Run standaardoptie voor het maken van taken is TaskCreationOptions.DenyChildAttach.
using System;
using System.Threading.Tasks;
public class AttachedExample
{
public static async Task Main()
{
await Task.Factory
.StartNew(
() =>
{
Console.WriteLine($"Running antecedent task {Task.CurrentId}...");
Console.WriteLine("Launching attached child tasks...");
for (int ctr = 1; ctr <= 5; ctr++)
{
int index = ctr;
Task.Factory.StartNew(async value =>
{
Console.WriteLine($" Attached child task #{value} running");
await Task.Delay(1000);
}, index, TaskCreationOptions.AttachedToParent);
}
Console.WriteLine("Finished launching attached child tasks...");
}).ContinueWith(
antecedent =>
Console.WriteLine($"Executing continuation of Task {antecedent.Id}"));
}
}
// The example displays the similar output:
// Running antecedent task 1...
// Launching attached child tasks...
// Finished launching attached child tasks...
// Attached child task #1 running
// Attached child task #5 running
// Attached child task #3 running
// Attached child task #2 running
// Attached child task #4 running
// Executing continuation of Task 1
Imports System.Threading
Imports System.Threading.Tasks
Public Module Example
Public Sub Main()
Dim t = Task.Factory.StartNew(Sub()
Console.WriteLine("Running antecedent task {0}...",
Task.CurrentId)
Console.WriteLine("Launching attached child tasks...")
For ctr As Integer = 1 To 5
Dim index As Integer = ctr
Task.Factory.StartNew(Sub(value)
Console.WriteLine(" Attached child task #{0} running",
value)
Thread.Sleep(1000)
End Sub, index, TaskCreationOptions.AttachedToParent)
Next
Console.WriteLine("Finished launching attached child tasks...")
End Sub)
Dim continuation = t.ContinueWith(Sub(antecedent)
Console.WriteLine("Executing continuation of Task {0}",
antecedent.Id)
End Sub)
continuation.Wait()
End Sub
End Module
' The example displays the following output:
' Running antecedent task 1...
' Launching attached child tasks...
' Finished launching attached child tasks...
' Attached child task #5 running
' Attached child task #1 running
' Attached child task #2 running
' Attached child task #3 running
' Attached child task #4 running
' Executing continuation of Task 1
Als onderliggende taken echter worden losgekoppeld van de antecedent, wordt de voortzetting uitgevoerd zodra de antecedent is beëindigd, ongeacht de status van de onderliggende taken. Als gevolg hiervan kunnen meerdere uitvoeringen van het volgende voorbeeld variabele uitvoer produceren die afhankelijk is van hoe de taakplanner elke onderliggende taak heeft verwerkt:
using System;
using System.Threading.Tasks;
public class DetachedExample
{
public static async Task Main()
{
Task task =
Task.Factory.StartNew(
() =>
{
Console.WriteLine($"Running antecedent task {Task.CurrentId}...");
Console.WriteLine("Launching attached child tasks...");
for (int ctr = 1; ctr <= 5; ctr++)
{
int index = ctr;
Task.Factory.StartNew(
async value =>
{
Console.WriteLine($" Attached child task #{value} running");
await Task.Delay(1000);
}, index);
}
Console.WriteLine("Finished launching detached child tasks...");
}, TaskCreationOptions.DenyChildAttach);
Task continuation =
task.ContinueWith(
antecedent =>
Console.WriteLine($"Executing continuation of Task {antecedent.Id}"));
await continuation;
Console.ReadLine();
}
}
// The example displays the similar output:
// Running antecedent task 1...
// Launching attached child tasks...
// Finished launching detached child tasks...
// Executing continuation of Task 1
// Attached child task #1 running
// Attached child task #5 running
// Attached child task #2 running
// Attached child task #3 running
// Attached child task #4 running
Imports System.Threading
Imports System.Threading.Tasks
Public Module Example
Public Sub Main()
Dim t = Task.Factory.StartNew(Sub()
Console.WriteLine("Running antecedent task {0}...",
Task.CurrentId)
Console.WriteLine("Launching attached child tasks...")
For ctr As Integer = 1 To 5
Dim index As Integer = ctr
Task.Factory.StartNew(Sub(value)
Console.WriteLine(" Attached child task #{0} running",
value)
Thread.Sleep(1000)
End Sub, index)
Next
Console.WriteLine("Finished launching detached child tasks...")
End Sub, TaskCreationOptions.DenyChildAttach)
Dim continuation = t.ContinueWith(Sub(antecedent)
Console.WriteLine("Executing continuation of Task {0}",
antecedent.Id)
End Sub)
continuation.Wait()
End Sub
End Module
' The example displays output like the following:
' Running antecedent task 1...
' Launching attached child tasks...
' Finished launching detached child tasks...
' Attached child task #1 running
' Attached child task #2 running
' Attached child task #5 running
' Attached child task #3 running
' Executing continuation of Task 1
' Attached child task #4 running
De uiteindelijke status van de antecedent-taak is afhankelijk van de uiteindelijke status van gekoppelde onderliggende taken. De status van losgekoppelde onderliggende taken heeft geen invloed op het bovenliggende item. Zie Gekoppelde en losgekoppelde onderliggende taken voor meer informatie.
Status koppelen aan vervolgen
U kunt willekeurige status koppelen aan een taakvervolging. De ContinueWith methode biedt overbelaste versies die elk een Object waarde aannemen die de status van de voortzetting vertegenwoordigt. U kunt dit statusobject later openen met behulp van de Task.AsyncState eigenschap. Dit statusobject is null als u geen waarde opgeeft.
De vervolgstatus is handig wanneer u bestaande code converteert die gebruikmaakt van het Asynchrone programmeermodel (APM) om de TPL te gebruiken. In de APM kunt u de objectstatus opgeven in de methode Beginmethode en later kunt u de IAsyncResult.AsyncState eigenschap gebruiken om toegang te krijgen tot die status. Als u deze status wilt behouden wanneer u een code converteert die gebruikmaakt van de APM om de TPL te gebruiken, gebruikt u de ContinueWith methode.
Vervolgstatus kan ook nuttig zijn wanneer u met Task objecten in het Visual Studio-foutopsporingsprogramma werkt. In het venster Parallelle taken geeft de kolom Taak bijvoorbeeld de tekenreeksweergave weer van het statusobject voor elke taak. Zie Het venster Taken gebruiken voor meer informatie over het venster Parallelle taken.
In het volgende voorbeeld ziet u hoe u de vervolgstatus gebruikt. Er wordt een keten van vervolgtaken gemaakt. Elke taak bevat de huidige tijd, een DateTime object, voor de state parameter van de ContinueWith methode. Elk DateTime object vertegenwoordigt het tijdstip waarop de vervolgtaak wordt gemaakt. Elke taak produceert als resultaat een tweede DateTime object dat het tijdstip aangeeft waarop de taak is voltooid. Nadat alle taken zijn voltooid, worden in dit voorbeeld de aanmaaktijd en het tijdstip weergegeven waarop elke vervolgtaak is voltooid.
using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
class ContinuationStateExample
{
static DateTime DoWork()
{
Thread.Sleep(2000);
return DateTime.Now;
}
static async Task Main()
{
Task<DateTime> task = Task.Run(() => DoWork());
var continuations = new List<Task<DateTime>>();
for (int i = 0; i < 5; i++)
{
task = task.ContinueWith((antecedent, _) => DoWork(), DateTime.Now);
continuations.Add(task);
}
await task;
foreach (Task<DateTime> continuation in continuations)
{
DateTime start = (DateTime)continuation.AsyncState!;
DateTime end = continuation.Result;
Console.WriteLine($"Task was created at {start.TimeOfDay} and finished at {end.TimeOfDay}.");
}
Console.ReadLine();
}
}
// The example displays the similar output:
// Task was created at 10:56:21.1561762 and finished at 10:56:25.1672062.
// Task was created at 10:56:21.1610677 and finished at 10:56:27.1707646.
// Task was created at 10:56:21.1610677 and finished at 10:56:29.1743230.
// Task was created at 10:56:21.1610677 and finished at 10:56:31.1779883.
// Task was created at 10:56:21.1610677 and finished at 10:56:33.1837083.
Imports System.Collections.Generic
Imports System.Threading
Imports System.Threading.Tasks
' Demonstrates how to associate state with task continuations.
Public Module ContinuationState
' Simulates a lengthy operation and returns the time at which
' the operation completed.
Public Function DoWork() As Date
' Simulate work by suspending the current thread
' for two seconds.
Thread.Sleep(2000)
' Return the current time.
Return Date.Now
End Function
Public Sub Main()
' Start a root task that performs work.
Dim t As Task(Of Date) = Task(Of Date).Run(Function() DoWork())
' Create a chain of continuation tasks, where each task is
' followed by another task that performs work.
Dim continuations As New List(Of Task(Of DateTime))()
For i As Integer = 0 To 4
' Provide the current time as the state of the continuation.
t = t.ContinueWith(Function(antecedent, state) DoWork(), DateTime.Now)
continuations.Add(t)
Next
' Wait for the last task in the chain to complete.
t.Wait()
' Display the creation time of each continuation (the state object)
' and the completion time (the result of that task) to the console.
For Each continuation In continuations
Dim start As DateTime = CDate(continuation.AsyncState)
Dim [end] As DateTime = continuation.Result
Console.WriteLine("Task was created at {0} and finished at {1}.",
start.TimeOfDay, [end].TimeOfDay)
Next
End Sub
End Module
' The example displays output like the following:
' Task was created at 10:56:21.1561762 and finished at 10:56:25.1672062.
' Task was created at 10:56:21.1610677 and finished at 10:56:27.1707646.
' Task was created at 10:56:21.1610677 and finished at 10:56:29.1743230.
' Task was created at 10:56:21.1610677 and finished at 10:56:31.1779883.
' Task was created at 10:56:21.1610677 and finished at 10:56:33.1837083.
Vervolgen die taaktypen retourneren
Soms moet u een vervolg koppelen dat een Task type retourneert. Deze taken worden geneste taken genoemd. Wanneer een bovenliggende taak een taak aanroept en een taak retourneertTask<TResult>.ContinueWith, kunt u aanroepen Unwrap om een proxytaak te maken die de asynchrone bewerking van de <Task<Task<T>>> of Task(Of Task(Of T)) (Visual Basic) vertegenwoordigt.continuationFunction
In het volgende voorbeeld ziet u hoe u vervolgen gebruikt waarmee extra functies voor het retourneren van taken worden verpakt. Elke voortzetting kan worden uitgepakt, waarbij de binnenste taak wordt weergegeven die is verpakt.
using System;
using System.Threading;
using System.Threading.Tasks;
public class UnwrapExample
{
public static async Task Main()
{
Task<int> taskOne = RemoteIncrement(0);
Console.WriteLine("Started RemoteIncrement(0)");
Task<int> taskTwo = RemoteIncrement(4)
.ContinueWith(t => RemoteIncrement(t.Result))
.Unwrap().ContinueWith(t => RemoteIncrement(t.Result))
.Unwrap().ContinueWith(t => RemoteIncrement(t.Result))
.Unwrap();
Console.WriteLine("Started RemoteIncrement(...(RemoteIncrement(RemoteIncrement(4))...)");
try
{
await taskOne;
Console.WriteLine("Finished RemoteIncrement(0)");
await taskTwo;
Console.WriteLine("Finished RemoteIncrement(...(RemoteIncrement(RemoteIncrement(4))...)");
}
catch (Exception e)
{
Console.WriteLine($"A task has thrown the following (unexpected) exception:\n{e}");
}
}
static Task<int> RemoteIncrement(int number) =>
Task<int>.Factory.StartNew(
obj =>
{
Thread.Sleep(1000);
int x = (int)(obj!);
Console.WriteLine("Thread={0}, Next={1}", Thread.CurrentThread.ManagedThreadId, ++x);
return x;
},
number);
}
// The example displays the similar output:
// Started RemoteIncrement(0)
// Started RemoteIncrement(...(RemoteIncrement(RemoteIncrement(4))...)
// Thread=4, Next=1
// Finished RemoteIncrement(0)
// Thread=5, Next=5
// Thread=6, Next=6
// Thread=6, Next=7
// Thread=6, Next=8
// Finished RemoteIncrement(...(RemoteIncrement(RemoteIncrement(4))...)
Imports System.Threading
Module UnwrapExample
Sub Main()
Dim taskOne As Task(Of Integer) = RemoteIncrement(0)
Console.WriteLine("Started RemoteIncrement(0)")
Dim taskTwo As Task(Of Integer) = RemoteIncrement(4).
ContinueWith(Function(t) RemoteIncrement(t.Result)).
Unwrap().ContinueWith(Function(t) RemoteIncrement(t.Result)).
Unwrap().ContinueWith(Function(t) RemoteIncrement(t.Result)).
Unwrap()
Console.WriteLine("Started RemoteIncrement(...(RemoteIncrement(RemoteIncrement(4))...)")
Try
taskOne.Wait()
Console.WriteLine("Finished RemoteIncrement(0)")
taskTwo.Wait()
Console.WriteLine("Finished RemoteIncrement(...(RemoteIncrement(RemoteIncrement(4))...)")
Catch e As AggregateException
Console.WriteLine($"A task has thrown the following (unexpected) exception:{vbLf}{e}")
End Try
End Sub
Function RemoteIncrement(ByVal number As Integer) As Task(Of Integer)
Return Task(Of Integer).Factory.StartNew(
Function(obj)
Thread.Sleep(1000)
Dim x As Integer = CInt(obj)
Console.WriteLine("Thread={0}, Next={1}", Thread.CurrentThread.ManagedThreadId, Interlocked.Increment(x))
Return x
End Function, number)
End Function
End Module
' The example displays the similar output:
' Started RemoteIncrement(0)
' Started RemoteIncrement(...(RemoteIncrement(RemoteIncrement(4))...)
' Thread=4, Next=1
' Finished RemoteIncrement(0)
' Thread=5, Next=5
' Thread=6, Next=6
' Thread=6, Next=7
' Thread=6, Next=8
' Finished RemoteIncrement(...(RemoteIncrement(RemoteIncrement(4))...)
Zie Procedure: Een geneste taak uitpakken voor meer informatie over het gebruik.Unwrap
Uitzonderingen verwerken die zijn gegenereerd door vervolgen
Een antecedent-vervolgrelatie is geen bovenliggende-onderliggende relatie. Uitzonderingen die worden gegenereerd door vervolgen, worden niet doorgegeven aan de antecedent. Om die reden kunt u uitzonderingen verwerken die worden veroorzaakt door vervolgen, zoals u ze in een andere taak zou afhandelen, als volgt:
- U kunt de Waitmethode , WaitAllof WaitAny de bijbehorende generieke tegenhanger gebruiken om te wachten op de voortzetting. U kunt wachten op een antecedent en de bijbehorende vervolgen in dezelfde
tryinstructie, zoals wordt weergegeven in het volgende voorbeeld:
using System;
using System.Threading.Tasks;
public class ExceptionExample
{
public static async Task Main()
{
Task<int> task = Task.Run(
() =>
{
Console.WriteLine($"Executing task {Task.CurrentId}");
return 54;
});
var continuation = task.ContinueWith(
antecedent =>
{
Console.WriteLine($"Executing continuation task {Task.CurrentId}");
Console.WriteLine($"Value from antecedent: {antecedent.Result}");
throw new InvalidOperationException();
});
try
{
await task;
await continuation;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
}
// The example displays the similar output:
// Executing task 1
// Executing continuation task 2
// Value from antecedent: 54
// Operation is not valid due to the current state of the object.
Imports System.Threading.Tasks
Module Example
Public Sub Main()
Dim task1 = Task(Of Integer).Run(Function()
Console.WriteLine("Executing task {0}",
Task.CurrentId)
Return 54
End Function)
Dim continuation = task1.ContinueWith(Sub(antecedent)
Console.WriteLine("Executing continuation task {0}",
Task.CurrentId)
Console.WriteLine("Value from antecedent: {0}",
antecedent.Result)
Throw New InvalidOperationException()
End Sub)
Try
task1.Wait()
continuation.Wait()
Catch ae As AggregateException
For Each ex In ae.InnerExceptions
Console.WriteLine(ex.Message)
Next
End Try
End Sub
End Module
' The example displays the following output:
' Executing task 1
' Executing continuation task 2
' Value from antecedent: 54
' Operation is not valid due to the current state of the object.
- U kunt een tweede vervolg gebruiken om de Exception eigenschap van de eerste voortzetting te observeren. In het volgende voorbeeld probeert een taak te lezen uit een niet-bestaand bestand. De voortzetting geeft vervolgens informatie weer over de uitzondering in de antecedent-taak.
using System;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
public class ExceptionTwoExample
{
public static async Task Main()
{
var task = Task.Run(
() =>
{
string fileText = File.ReadAllText(@"C:\NonexistentFile.txt");
return fileText;
});
Task continuation = task.ContinueWith(
antecedent =>
{
var fileNotFound =
antecedent.Exception
?.InnerExceptions
?.FirstOrDefault(e => e is FileNotFoundException) as FileNotFoundException;
if (fileNotFound != null)
{
Console.WriteLine(fileNotFound.Message);
}
}, TaskContinuationOptions.OnlyOnFaulted);
await continuation;
Console.ReadLine();
}
}
// The example displays the following output:
// Could not find file 'C:\NonexistentFile.txt'.
Imports System.IO
Imports System.Threading.Tasks
Module Example
Public Sub Main()
Dim t = Task.Run(Function()
Dim s As String = File.ReadAllText("C:\NonexistentFile.txt")
Return s
End Function)
Dim c = t.ContinueWith(Sub(antecedent)
' Get the antecedent's exception information.
For Each ex In antecedent.Exception.InnerExceptions
If TypeOf ex Is FileNotFoundException
Console.WriteLine(ex.Message)
End If
Next
End Sub, TaskContinuationOptions.OnlyOnFaulted)
c.Wait()
End Sub
End Module
' The example displays the following output:
' Could not find file 'C:\NonexistentFile.txt'.
Omdat deze is uitgevoerd met de TaskContinuationOptions.OnlyOnFaulted optie, wordt de voortzetting alleen uitgevoerd als er een uitzondering optreedt in de antecedent. Daarom kan worden aangenomen dat de eigenschap van Exception de antecedent niet nullis. Als de voortzetting wordt uitgevoerd of er al dan niet een uitzondering wordt gegenereerd in de antecedent, moet deze controleren of de eigenschap van Exception de antecedent niet null is voordat de uitzondering wordt verwerkt, zoals in het volgende codefragment wordt weergegeven:
var fileNotFound =
antecedent.Exception
?.InnerExceptions
?.FirstOrDefault(e => e is FileNotFoundException) as FileNotFoundException;
if (fileNotFound != null)
{
Console.WriteLine(fileNotFound.Message);
}
' Determine whether an exception occurred.
If antecedent.Exception IsNot Nothing Then
' Get the antecedent's exception information.
For Each ex In antecedent.Exception.InnerExceptions
If TypeOf ex Is FileNotFoundException
Console.WriteLine(ex.Message)
End If
Next
End If
Zie Uitzonderingsafhandeling voor meer informatie.
- Als de voortzetting een gekoppelde onderliggende taak is die is gemaakt met behulp van de TaskContinuationOptions.AttachedToParent optie, worden de uitzonderingen door de bovenliggende back doorgegeven aan de aanroepende thread, zoals het geval is in een ander gekoppeld onderliggend element. Zie Gekoppelde en losgekoppelde onderliggende taken voor meer informatie.
