Mempertautkan tugas menggunakan tugas lanjutan

Dalam pemrograman asinkron, adalah umum bagi satu operasi asinkron untuk memanggil operasi kedua pada penyelesaian. Kelanjutan memungkinkan operasi pengikut untuk menggunakan hasil dari operasi pertama. Secara tradisional, kelanjutan telah dilakukan dengan menggunakan metode panggilan balik. Di Perpustakaan Tugas Paralel (TPL), fungsi yang sama disediakan oleh tugas lanjutan . Tugas kelanjutan (juga dikenal hanya sebagai kelanjutan) adalah tugas asinkron yang dipanggil oleh tugas lain, yang dikenal sebagai pendahulu, ketika tugas pendahulu selesai.

Lanjutan relatif mudah digunakan, tetapi tetap kuat dan fleksibel. Misalnya, Anda dapat:

• Salurkan data dari pendahuluan ke lanjutan.
• Tentukan kondisi yang tepat di mana kelanjutan akan dipanggil atau tidak dipanggil.
• Batalkan kelanjutan baik sebelum dimulai maupun secara kolaboratif saat sedang berjalan.
• Berikan petunjuk tentang bagaimana kelanjutan harus dijadwalkan.
• Panggil beberapa kelanjutan dari pendahuluan yang sama.
• Panggil satu kelanjutan ketika semua atau salah satu dari beberapa anteseden selesai.
• Rangkaian lanjutan secara berurutan hingga panjang yang diinginkan.
• Gunakan kelanjutan untuk menangani pengecualian yang terjadi pada pendahulu.

Tentang kelanjutan

Kelanjutan adalah tugas yang dibuat dalam status WaitingForActivation. Ini diaktifkan secara otomatis ketika tugas sebelumnya selesai. Memanggil Task.Start pada kelanjutan dalam kode pengguna memberikan pengecualian System.InvalidOperationException.

Kelanjutan itu sendiri adalah Task dan tidak memblokir utas tempat kelanjutan tersebut dimulai. Panggil metode Task.Wait untuk memblokir hingga tugas kelanjutan selesai.

Menciptakan kelanjutan untuk satu pendahulu

Anda membuat kelanjutan yang dijalankan ketika antecedent-nya telah selesai dengan memanggil metode Task.ContinueWith. Contoh berikut menunjukkan pola dasar (untuk kejelasan, penanganan pengecualian dihilangkan). Ini menjalankan tugas pendahulu taskA yang mengembalikan objek DayOfWeek yang menunjukkan nama hari dalam minggu ini. Ketika taskA selesai, antecedent mewakili hasilnya dalam metode kelanjutan ContinueWith. Hasil tugas pendahulu ditulis ke konsol.

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.

Membuat kelanjutan untuk beberapa anteceden

Anda juga dapat membuat kelanjutan yang akan berjalan ketika salah satu atau semua grup tugas telah selesai. Untuk menjalankan kelanjutan ketika semua tugas antecedent telah selesai, Anda dapat memanggil metode Shared statis (Task.WhenAll di Visual Basic) atau metode TaskFactory.ContinueWhenAll instans. Untuk melanjutkan eksekusi ketika salah satu dari tugas-tugas sebelumnya telah selesai, Anda dapat memanggil metode statis Shared (Task.WhenAny di Visual Basic) atau metode TaskFactory.ContinueWhenAny instan.

Panggilan ke Task.WhenAll dan kelebihan beban Task.WhenAny tidak memblokir utas panggilan. Namun, Anda biasanya memanggil semua kecuali metode Task.WhenAll(IEnumerable<Task>) dan Task.WhenAll(Task[]) untuk mengambil properti Task<TResult>.Result yang dikembalikan, yang memblokir utas panggilan.

Contoh berikut memanggil metode Task.WhenAll(IEnumerable<Task>) untuk membuat tugas kelanjutan yang mencerminkan hasil dari 10 tugas pendahulunya. Setiap tugas sebelumnya mengkuadratkan nilai indeks yang berkisar dari satu hingga 10. Jika antecedent berhasil diselesaikan (properti Task.Status mereka TaskStatus.RanToCompletion), properti Task<TResult>.Result pada kelanjutan berupa array dari nilai Task<TResult>.Result yang dikembalikan oleh setiap antecedent. Contoh menambahkannya untuk menghitung jumlah kuadrat untuk semua angka antara satu dan 10:

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

Opsi kelanjutan

Saat Anda membuat kelanjutan tugas tunggal, Anda dapat menggunakan kelebihan beban ContinueWith yang mengambil nilai enumerasi System.Threading.Tasks.TaskContinuationOptions untuk menentukan kondisi di mana kelanjutan dimulai. Misalnya, Anda dapat menentukan bahwa kelanjutan hanya dijalankan jika pendahulu berhasil diselesaikan, atau hanya jika berakhir dalam keadaan gagal. Jika kondisi tidak benar ketika antecedent siap untuk memanggil kelanjutan, maka kelanjutan tersebut langsung beralih ke keadaan TaskStatus.Canceled dan tidak dapat dimulai lagi.

Banyak metode kelanjutan multi-tugas, seperti kelebihan beban metode TaskFactory.ContinueWhenAll, juga menyertakan parameter System.Threading.Tasks.TaskContinuationOptions. Namun, hanya sebagian anggota dari seluruh enumerasi System.Threading.Tasks.TaskContinuationOptions yang valid. Anda dapat menentukan nilai System.Threading.Tasks.TaskContinuationOptions yang memiliki mitra dalam enumerasi System.Threading.Tasks.TaskCreationOptions, seperti TaskContinuationOptions.AttachedToParent, TaskContinuationOptions.LongRunning, dan TaskContinuationOptions.PreferFairness. Jika Anda menentukan salah satu opsi NotOn atau OnlyOn pada kelanjutan multi-tugas, ArgumentOutOfRangeException pengecualian akan dilemparkan pada runtime.

Untuk informasi selengkapnya tentang opsi kelanjutan tugas, lihat artikel TaskContinuationOptions.

Mengirimkan data ke proses lanjutan

Metode Task.ContinueWith meneruskan referensi ke pendahulu sebagai argumen ke delegasi kelanjutan pengguna. Jika antecedent adalah objek System.Threading.Tasks.Task<TResult>, dan tugas berjalan hingga selesai, maka kelanjutan dapat mengakses properti Task<TResult>.Result tugas.

Properti Task<TResult>.Result memblokir hingga tugas selesai. Namun, jika tugas dibatalkan atau mengalami kesalahan, mencoba mengakses properti Result akan melempar pengecualian AggregateException. Anda dapat menghindari masalah ini dengan menggunakan opsi OnlyOnRanToCompletion, seperti yang ditunjukkan dalam contoh berikut:

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?

Jika Anda ingin kelanjutan berjalan meskipun pendahulu tidak mencapai penyelesaian yang berhasil, Anda harus mengantisipasi pengecualian. Salah satu pendekatannya adalah menguji properti Task.Status dari antecedent, dan hanya mencoba mengakses properti Result jika statusnya tidak Faulted atau Canceled. Anda juga dapat memeriksa properti Exception dari antecedent. Untuk informasi selengkapnya, lihat Penanganan Pengecualian. Contoh berikut membuat perubahan pada contoh sebelumnya untuk mengakses properti Task<TResult>.Result dari antecedent hanya jika statusnya adalah 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?

Membatalkan kelanjutan proses

Properti Task.Status lanjutan diatur ke TaskStatus.Canceled dalam situasi berikut:

• Ini melemparkan pengecualian OperationCanceledException sebagai respons terhadap permintaan pembatalan. Seperti halnya tugas apa pun, jika pengecualian berisi token yang sama yang diteruskan ke kelanjutan, itu diperlakukan sebagai pengakuan pembatalan yang bersifat kooperatif.

• Kelanjutannya diteruskan ke System.Threading.CancellationToken yang memiliki properti IsCancellationRequested yaitu true. Dalam hal ini, kelanjutan tidak dimulai, dan bertransisi ke status TaskStatus.Canceled.

• Kelanjutan tidak pernah berjalan karena kondisi yang ditetapkan oleh argumen TaskContinuationOptions tidak terpenuhi. Misalnya, jika antecedent memasuki status TaskStatus.Faulted, kelanjutannya yang diberikan pilihan TaskContinuationOptions.NotOnFaulted tidak akan berjalan namun akan beralih ke status Canceled.

Jika tugas dan kelanjutannya mewakili dua bagian dari operasi logis yang sama, Anda dapat meneruskan token pembatalan yang sama ke kedua tugas, seperti yang ditunjukkan dalam contoh berikut. Ini terdiri dari pendahulu yang menghasilkan daftar bilangan bulat yang dapat dibagi dengan 33, yang diteruskannya ke lanjutan. Kelanjutan kemudian menampilkan daftar. Baik pendahuluan maupun kelanjutan berhenti secara teratur dalam interval acak. Selain itu, objek System.Threading.Timer digunakan untuk menjalankan metode Elapsed setelah interval batas waktu lima detik. Contoh ini memanggil metode CancellationTokenSource.Cancel, yang menyebabkan tugas yang sedang dijalankan memanggil metode CancellationToken.ThrowIfCancellationRequested. Apakah metode CancellationTokenSource.Cancel dipanggil ketika antecedent atau kelanjutannya dijalankan tergantung pada durasi jeda yang dihasilkan secara acak. Jika syarat sebelumnya dibatalkan, kelanjutannya tidak akan dimulai. Jika antecedent tidak dibatalkan, token masih dapat digunakan untuk membatalkan kelanjutan.

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: {task.Status}");
        Console.WriteLine($"Continuation Status: {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

Anda juga dapat mencegah kelanjutan dari dijalankan jika antecedent-nya dibatalkan tanpa memberikan token pembatalan kepada kelanjutan. Berikan token dengan menentukan opsi TaskContinuationOptions.NotOnCanceled saat Anda membuat kelanjutan, seperti yang ditunjukkan dalam contoh berikut:

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

Setelah kelanjutan masuk ke status Canceled, hal ini dapat memengaruhi kelanjutan berikutnya, tergantung pada TaskContinuationOptions yang ditentukan untuk kelanjutan tersebut.

Lanjutan yang dibuang tidak dapat dimulai.

Kelanjutan dan tugas anak

Lanjutan tidak akan dijalankan sampai pendahulu dan semua tugas anak yang terlampir telah selesai. Kelanjutan tidak menunggu tugas anak yang dilepas selesai. Dua contoh berikut mengilustrasikan tugas anak yang dilampirkan dan dilepas dari antecedent yang membuat kelanjutan. Dalam contoh berikut, kelanjutan hanya berjalan setelah semua tugas turunan selesai, dan beberapa kali eksekusi dari contoh menghasilkan output yang identik setiap kali dieksekusi. Contoh meluncurkan antecedent dengan memanggil metode TaskFactory.StartNew karena secara default metode Task.Run membuat tugas induk yang opsi pembuatan tugas defaultnya 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

Namun, jika tugas anak terlepas dari pendahulu, proses kelanjutan akan berjalan segera sesudah pendahulu dihentikan, terlepas dari status tugas anak. Akibatnya, beberapa eksekusi contoh berikut dapat menghasilkan output variabel yang bergantung pada bagaimana penjadwal tugas menangani setiap tugas anak:

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

Status akhir tugas sebelumnya tergantung pada status akhir tugas anak yang terlampir. Status tugas anak yang terpisah tidak memengaruhi tugas induk. Untuk informasi selengkapnya, lihat Tugas Anak yang Terlampir dan yang Tidak Terlampir.

Mengaitkan status dengan kelanjutan

Anda dapat mengaitkan status arbitrer dengan kelanjutan tugas. Metode ContinueWith menyediakan versi kelebihan beban yang masing-masing mengambil nilai Object yang mewakili status kelanjutan. Anda nantinya dapat mengakses objek status ini dengan menggunakan properti Task.AsyncState. Objek status ini null jika Anda tidak memberikan nilai.

Status kelanjutan berguna saat Anda mengonversi kode yang ada yang menggunakan Asynchronous Programming Model (APM) untuk menggunakan TPL. Dalam APM, Anda dapat memberikan status objek dalam metode Mulai dan kemudian Anda dapat menggunakan properti IAsyncResult.AsyncState untuk mengakses status tersebut. Untuk mempertahankan status ini saat Mengonversi kode yang menggunakan APM untuk menggunakan TPL, Anda menggunakan metode ContinueWith.

Status kelanjutan juga dapat berguna saat Anda bekerja dengan objek Task di debugger Visual Studio. Misalnya, di jendela Tugas Paralel, kolom Tugas menampilkan representasi string objek status untuk setiap tugas. Untuk informasi selengkapnya tentang jendela Tugas Paralel, lihat Menggunakan Jendela Tugas.

Contoh berikut menunjukkan cara menggunakan status kelanjutan. Ini membuat rantai tugas kelanjutan. Setiap tugas menyediakan waktu saat ini, objek DateTime, untuk parameter state metode ContinueWith. Setiap objek DateTime mewakili waktu di mana tugas kelanjutan dibuat. Setiap tugas menghasilkan sebagai hasilnya objek DateTime kedua yang mewakili waktu tugas selesai. Setelah semua tugas selesai, contoh ini menampilkan waktu pembuatan dan waktu di mana setiap tugas kelanjutan selesai.

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.

Kelanjutan yang mengembalikan jenis Tugas

Terkadang Anda mungkin perlu menautkan rangkaian yang mengembalikan jenis Task. Tugas-tugas ini disebut sebagai tugas berlapis. Saat tugas induk memanggil Task<TResult>.ContinueWith dan menyediakan continuationFunction yang mengembalikan tugas, Anda dapat memanggil Unwrap untuk membuat tugas proksi yang mewakili operasi asinkron <Task<Task<T>>> atau Task(Of Task(Of T)) (Visual Basic).

Contoh berikut menunjukkan cara menggunakan kelanjutan yang membungkus fungsi pengembalian tugas tambahan. Setiap kelanjutan dapat dibongkar, mengekspos tugas dalam yang dibungkus.

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))...)

Untuk informasi selengkapnya tentang menggunakan Unwrap, lihat Cara: Membongkar Tugas berlapis.

Menangani pengecualian yang dilemparkan dari lanjutan

Relasi kelanjutan antecedent bukanlah relasi orang tua-anak. Pengecualian yang ditimbulkan oleh kelanjutan tidak diteruskan ke pendahulu. Oleh karena itu, tangani pengecualian yang dilemparkan oleh kelanjutan seperti Anda menangani dalam tugas lainnya, sebagai berikut:

• Anda dapat menggunakan metode Wait, WaitAll, atau WaitAny, atau rekan generiknya, untuk menunggu kelanjutannya. Anda dapat menunggu sebuah anteceden beserta lanjutannya dalam pernyataan try yang sama, seperti yang ditunjukkan dalam contoh berikut ini.

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.

• Anda dapat menggunakan kelanjutan kedua untuk mengamati fitur Exception dari kelanjutan pertama. Dalam contoh berikut, tugas mencoba membaca dari file yang tidak ada. Langkah berikutnya kemudian menampilkan informasi tentang pengecualian dalam tugas sebelumnya.

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'.

Karena dijalankan dengan opsi TaskContinuationOptions.OnlyOnFaulted, kelanjutan hanya dijalankan jika pengecualian terjadi di antecedent. Oleh karena itu dapat diasumsikan bahwa properti Exception dari antecedent tidak null. Jika kelanjutan dijalankan terlepas dari apakah pengecualian terjadi dalam antecedent atau tidak, maka harus diperiksa apakah properti Exception dari antecedent tidak null sebelum mencoba menangani pengecualian, seperti yang ditunjukkan oleh fragmen kode berikut:

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

Untuk informasi selengkapnya, lihat Penanganan Pengecualian.

• Jika kelanjutan adalah tugas anak terlampir yang dibuat dengan menggunakan opsi TaskContinuationOptions.AttachedToParent, pengecualiannya akan disebarluaskan oleh induk kembali ke utas panggilan, seperti halnya pada anak terlampir lainnya. Untuk informasi selengkapnya, lihat Tugas Anak yang Terlampir dan yang Tidak Terlampir.

Lihat juga

• Pustaka Paralel Tugas (TPL)