Task.CancelAndException.txt

----------
20200302
ref:
https://docs.microsoft.com/zh-tw/dotnet/standard/parallel-programming/how-to-cancel-a-task-and-its-children


此範例示範如何終止 Task 及其子系，以回應取消要求。 這個範例也會說明在使用者委派藉由擲回 TaskCanceledException 結束時，呼叫端執行緒可以選擇性地使用 Wait 方法或 WaitAll 方法等候工作完成。 在這種情況下，您必須使用 try/catch 區塊來處理呼叫端執行緒上的例外狀況。

using System;
using System.Collections.Concurrent;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
    public static async Task Main()
    {
        var tokenSource = new CancellationTokenSource();
        var token = tokenSource.Token;

        // Store references to the tasks so that we can wait on them and
        // observe their status after cancellation.
        Task t;
        var tasks = new ConcurrentBag<Task>();

        Console.WriteLine("Press any key to begin tasks...");
        Console.ReadKey(true);
        Console.WriteLine("To terminate the example, press 'c' to cancel and exit...");
        Console.WriteLine();

        // Request cancellation of a single task when the token source is canceled.
        // Pass the token to the user delegate, and also to the task so it can
        // handle the exception correctly.
        t = Task.Run(() => DoSomeWork(1, token), token); // 呼叫函數跟 Task 都需要 CancellationTokenSource.Token, 才能處理(使用者取消 和 Task exception).
        Console.WriteLine("Task {0} executing", t.Id);
        tasks.Add(t);

        // Request cancellation of a task and its children. Note the token is passed
        // to (1) the user delegate and (2) as the second argument to Task.Run, so
        // that the task instance can correctly handle the OperationCanceledException.
        t = Task.Run(() =>
        {
            // Create some cancelable child tasks.
            Task tc;
            for (int i = 3; i <= 10; i++)
            {
                // For each child task, pass the same token
                // to each user delegate and to Task.Run.
                tc = Task.Run(() => DoSomeWork(i, token), token); // 每一個子函數跟 Task 都需要 CancellationTokenSource.Token, 才能處理(使用者取消 和 Task exception)
                Console.WriteLine("Task {0} executing", tc.Id);
                tasks.Add(tc);
                // Pass the same token again to do work on the parent task.
                // All will be signaled by the call to tokenSource.Cancel below.
                DoSomeWork(2, token); // 母函數也需要 CancellationTokenSource.Token, 才能處理(使用者取消 和 Task exception)
            }
        }, token);

        Console.WriteLine("Task {0} executing", t.Id);
        tasks.Add(t);

        // Request cancellation from the UI thread. 
        char ch = Console.ReadKey().KeyChar;
        if (ch == 'c' || ch == 'C')
        {
            tokenSource.Cancel();
            Console.WriteLine("\nTask cancellation requested.");

            // Optional: Observe the change in the Status property on the task. 
            // It is not necessary to wait on tasks that have canceled. However, 
            // if you do wait, you must enclose the call in a try-catch block to 
            // catch the TaskCanceledExceptions that are thrown. If you do  
            // not wait, no exception is thrown if the token that was passed to the  
            // Task.Run method is the same token that requested the cancellation.
        }

        try
        {
            await Task.WhenAll(tasks.ToArray());
        }
        catch (OperationCanceledException)
        {
            Console.WriteLine($"\n{nameof(OperationCanceledException)} thrown\n");
        }
        finally
        {
            tokenSource.Dispose();
        }

        // Display status of all tasks. 
        foreach (var task in tasks)
            Console.WriteLine("Task {0} status is now {1}", task.Id, task.Status);
    }

    static void DoSomeWork(int taskNum, CancellationToken ct)
    {
        // Was cancellation already requested?
        if (ct.IsCancellationRequested)
        {
            Console.WriteLine("Task {0} was cancelled before it got started.",
                              taskNum);
            ct.ThrowIfCancellationRequested();
        }

        int maxIterations = 100;

        // NOTE!!! A "TaskCanceledException was unhandled
        // by user code" error will be raised here if "Just My Code"
        // is enabled on your computer. On Express editions JMC is
        // enabled and cannot be disabled. The exception is benign.
        // Just press F5 to continue executing your code.
        for (int i = 0; i <= maxIterations; i++)
        {
            // Do a bit of work. Not too much.
            var sw = new SpinWait();
            for (int j = 0; j <= 100; j++)
                sw.SpinOnce();

            if (ct.IsCancellationRequested)
            {
                Console.WriteLine("Task {0} cancelled", taskNum);
                ct.ThrowIfCancellationRequested();
            }
        }
    }
}
// The example displays output like the following:
//       Press any key to begin tasks...
//    To terminate the example, press 'c' to cancel and exit...
//    
//    Task 1 executing
//    Task 2 executing
//    Task 3 executing
//    Task 4 executing
//    Task 5 executing
//    Task 6 executing
//    Task 7 executing
//    Task 8 executing
//    c
//    Task cancellation requested.
//    Task 2 cancelled
//    Task 7 cancelled
//    
//    OperationCanceledException thrown
//    
//    Task 2 status is now Canceled
//    Task 1 status is now RanToCompletion
//    Task 8 status is now Canceled
//    Task 7 status is now Canceled
//    Task 6 status is now RanToCompletion
//    Task 5 status is now RanToCompletion
//    Task 4 status is now RanToCompletion
//    Task 3 status is now RanToCompletion

----------
20181221

        void SampleTaskCancelAndException()
        {
            // 使用 cancel.
            // 以下範例啟動12個Task: 3個正常結束, 3個例外結束, 3個還沒開始就先取消, 3個在執行中取消.

            // Create a cancellation token and cancel it.
            // 建立控制旗標: 設定為取消狀態.
            var source1 = new CancellationTokenSource();
            var token1 = source1.Token;
            source1.Cancel();

            // Create a cancellation token for later cancellation.
            // 建立控制旗標: 後續再控制取消否.
            var source2 = new CancellationTokenSource();
            var token2 = source2.Token;

            // Create a series of tasks that will complete, be cancelled, 
            // timeout, or throw an exception.
            Task[] tasks = new Task[12];
            for (int i = 0; i < 12; i++)
            {
                switch (i % 4)
                {
                    case 0:
                        // Task should run to completion.
                        // Task 可完全執行完畢.
                        tasks[i] = Task.Run(() => Thread.Sleep(2000));
                        break;
                    case 1:
                        // Task should be set to canceled state.
                        // Task 啟動時可指定控制旗標: 本例為還沒開始就先取消執行.
                        tasks[i] = Task.Run(() => Thread.Sleep(2000),
                                 token1);
                        break;
                    case 2:
                        // Task should throw an exception.
                        // Task 可拋出 exception, 留存在 task 中. 後續可透過AggregateException 之 InnerExceptions 取得留存在task 中的 exception.
                        tasks[i] = Task.Run(() => { throw new NotSupportedException(); });
                        break;
                    case 3:
                        // Task should examine cancellation token.
                        // Task 可檢查控制旗標, 決定是否繼續執行?
                        tasks[i] = Task.Run(() =>
                        {
                            Thread.Sleep(2000);
                            if (token2.IsCancellationRequested)
                                token2.ThrowIfCancellationRequested();
                            Thread.Sleep(500);
                        }, token2);
                        break;
                }
            }
            Thread.Sleep(250);
            // 取消Task繼續執行. 使用相同控制旗標的task, 都會收到取消狀態.
            source2.Cancel();

            try
            {
                Task.WaitAll(tasks);
                //tasks[0].Wait(); 也可以個別task 等待完成的方式.
            }
            catch (AggregateException ae)
            {
                // 必須透過 透過AggregateException 之 InnerExceptions 取得留存在task 中的 exception.
                Console.WriteLine("One or more exceptions occurred:");
                foreach (var ex in ae.InnerExceptions)
                    Console.WriteLine("   {0}: {1}", ex.GetType().Name, ex.Message);
            }

            Console.WriteLine("\nStatus of tasks:");
            foreach (var t in tasks)
            {
                Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status);
                if (t.Exception != null)
                {
                    foreach (var ex in t.Exception.InnerExceptions)
                        Console.WriteLine("      {0}: {1}", ex.GetType().Name,
                                          ex.Message);
                }
            }
            // The example displays output like the following:
            //   One or more exceptions occurred:
            //      TaskCanceledException: A task was canceled.
            //      NotSupportedException: Specified method is not supported.
            //      TaskCanceledException: A task was canceled.
            //      TaskCanceledException: A task was canceled.
            //      NotSupportedException: Specified method is not supported.
            //      TaskCanceledException: A task was canceled.
            //      TaskCanceledException: A task was canceled.
            //      NotSupportedException: Specified method is not supported.
            //      TaskCanceledException: A task was canceled.
            //   
            //   Status of tasks:
            //      Task #13: RanToCompletion
            //      Task #1: Canceled
            //      Task #3: Faulted
            //         NotSupportedException: Specified method is not supported.
            //      Task #8: Canceled
            //      Task #14: RanToCompletion
            //      Task #4: Canceled
            //      Task #6: Faulted
            //         NotSupportedException: Specified method is not supported.
            //      Task #7: Canceled
            //      Task #15: RanToCompletion
            //      Task #9: Canceled
            //      Task #11: Faulted
            //         NotSupportedException: Specified method is not supported.
            //      Task #12: Canceled

        }