[CLR via C#]26. 计算限制的异步操作

    ThreadPool.QueueUserWorkItem(ComputeBoundOp,5)    // 调用QueueUserWorkItem
    new Task(ComputeBoundOp,5).Start();                                // 用Task来做相同的事情

[FlagsAttribute, SerializableAttribute]
    public enum TaskCreationOptions
    {
        //指定应使用默认行为
        None             = 0x0,
        //提示 TaskScheduler 以一种尽可能公平的方式安排任务，这意味着较早安排的任务将更可能较早运行，而较晚安排运行的任务将更可能较晚运行。造成默认的TaskScheduler(任务调度器) 将线程池中的任务放到全局队列中，而不是放到一个工作者线程的本地队列中
        PreferFairness   = 0x1,
        //指定某个任务将是运行时间长、粗粒度的操作。 它会给TaskScheduler一个提议，告诉它线程可能要“长时间运行”,将由TaskScheduler 决定如何解析还这个提示。
        LongRunning      = 0x2,
        //将一个任务和它的父Task关联。
        AttachedToParent = 0x4,
#if NET_4_5
        //
        DenyChildAttach  = 0x8,
        HideScheduler    = 0x10
#endif
    }

    private static Int32 Sum(Int32 n) {
        Int32 sum = 0;
        for (; n > 0; n--) checked { sum += n; }    //如果n太大，这一行代码会抛出异常
        return sum;
    }

class Program
    {
        static void Main(string[] args)
        {
           // 创建 Task, 推迟启动它
            Task<Int32> t = new Task<Int32>(n => Sum((Int32)n), 10000);
 
            // 可以在以后某个时间启动任务
            t.Start();
 
            // 可以选择显式的等待任务完成
            t.Wait();
 
            Console.WriteLine("The sum is: " + t.Result);   //一个Int32的值
            Console.ReadLine();
        }
 
        private static Int32 Sum(Int32 n)
        {
            Int32 sum = 0;
            for (; n > 0; n--) checked { sum += n; }    //如果n太大，这一行代码会抛出异常
            return sum;
        }
 
    }

    static void Main(string[] args)
        {
            CancellationTokenSource cts = new CancellationTokenSource();
            Task<Int32> t = new Task<Int32>(() => Sum(cts.Token, 10000), cts.Token);
 
            t.Start();
 
            // 在之后的某个时间，取消CancellationTokenSource以取消Task
            cts.Cancel();
 
            try
            {
                // 如果任务已经取消，Result会抛出一个AggregateException
                Console.WriteLine("The sum is: " + t.Result);   // An Int32 value
            }
            catch (AggregateException ae)
            {
                // 将任何OperationCanceledException对象都视为已处理
                // 其他任何异常都造成抛出一个新的AggregateException，其中
                // 只包含未处理的异常      
                ae.Handle(e => e is OperationCanceledException);
 
                // 所有的异常都处理好之后，执行下面这一行
                Console.WriteLine("Sum was canceled");
            }
            Console.ReadLine();
    }

　　　　static void Main(string[] args)
        {
 
            // 创建 Task, 推迟启动它, 继续另一个任务
            Task<Int32> t = new Task<Int32>(n => Sum((Int32)n), 10000);
 
            // 可以在以后某个时间启动任务
            t.Start();
 
            // ContinueWith 返回一个 Task 但一般不再关心这个对象
            Task cwt = t.ContinueWith(task => Console.WriteLine("The sum is: " + task.Result));
            cwt.Wait();
 
            Console.ReadLine();
 
        }

[System.FlagsAttribute, System.SerializableAttribute]
    public enum TaskContinuationOptions
    {
        None                  = 0x00000,
        PreferFairness        = 0x00001,
        LongRunning           = 0x00002,
        AttachedToParent      = 0x00004,
#if NET_4_5
        DenyChildAttach       = 0x00008,
        HideScheduler         = 0x00010,
        LazyCancellation      = 0x00020,
#endif
        //指定不应在延续任务前面的任务已完成运行的情况下安排延续任务。 此选项对多任务延续无效。
        NotOnRanToCompletion  = 0x10000,
        //指定不应在延续任务前面的任务引发了未处理异常的情况下安排延续任务。 此选项对多任务延续无效。
        NotOnFaulted          = 0x20000,
        //指定不应在延续任务前面的任务已取消的情况下安排延续任务。 此选项对多任务延续无效。
        NotOnCanceled         = 0x40000,
        //指定只应在延续任务前面的任务已完成运行的情况下才安排延续任务。 此选项对多任务延续无效。
        OnlyOnRanToCompletion = 0x60000,
        //指定只有在延续任务前面的任务引发了未处理异常的情况下才应安排延续任务。 此选项对多任务延续无效。
        OnlyOnFaulted         = 0x50000,
        //指定只应在延续任务前面的任务已取消的情况下安排延续任务。此选项对多任务延续无效。
        OnlyOnCanceled        = 0x30000,
        //指定应同步执行延续任务。 指定此选项后，延续任务将在导致前面的任务转换为其最终状态的相同线程上运行。 如果在创建延续任务时已经完成前面的任务，则延续任务将在创建此延续任务的线程上运行。 只应同步执行运行时间非常短的延续任务。
        ExecuteSynchronously  = 0x80000,
    }

static void Main(string[] args)
        {
            Task<Int32> t = new Task<Int32>(n => Sum((Int32)n), 10000);
 
            t.Start();
 
            // 每个 ContinueWith 都返回一个 Task，但你不必关心这些Task对象
            t.ContinueWith(task => Console.WriteLine("The sum is: " + task.Result),
               TaskContinuationOptions.OnlyOnRanToCompletion);
            t.ContinueWith(task => Console.WriteLine("Sum threw: " + task.Exception),
               TaskContinuationOptions.OnlyOnFaulted);
            t.ContinueWith(task => Console.WriteLine("Sum was canceled"),
               TaskContinuationOptions.OnlyOnCanceled);
 
            Console.ReadLine();
 
        }

static void Main(string[] args)
        {
            Task<Int32[]> parent = new Task<Int32[]>(() =>
            {
                var results = new Int32[3]; // 创建数组来存储结果
 
                // 这个任务创建并启用了3个子任务
                new Task(() => results[0] = Sum(10000), TaskCreationOptions.AttachedToParent).Start();
                new Task(() => results[1] = Sum(20000), TaskCreationOptions.AttachedToParent).Start();
                new Task(() => results[2] = Sum(30000), TaskCreationOptions.AttachedToParent).Start();
 
                // 返回对数组的一个引用(即使数组元素可能还没有初始化)
                return results;
            });
 
            var cwt = parent.ContinueWith(parentTask => Array.ForEach(parentTask.Result, Console.WriteLine));
 
            parent.Start();
 
            Console.ReadLine();
 
        }

public enum TaskStatus
  {
    //这些标志指出了一个Task在其生命周期内的状态
    // 任务已显式创建，可以手动Start()这个任务
    Created,
    // 任务已隐式创建，会自动开始
    WaitingForActivation,
    // 任务已调度，但尚未运行
    WaitingToRun,
    // 任务正在运行
    Running,
    // 任务正在等待它的子任务完成，子任务完成后它才完成
    WaitingForChildrenToComplete,
    // 一个任务的最终状态是以下三种之一
    // 已成功完成执行的任务
    RanToCompletion,
    // 该任务已通过对其自身的 CancellationToken 引发 OperationCanceledException 对取消进行了确认，此时该标记处于已发送信号状态；或者在该任务开始执行之前，已向该任务的 CancellationToken 发出了信号
    Canceled,
    // 由于未处理异常的原因而完成的任务
    Faulted
  }

if (task.Status == TaskStatus.RanToCompleted ).......

var cts = new CancellationTokenSource();
                var tf = new TaskFactory<Int32>(cts.Token, TaskCreationOptions.AttachedToParent, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
 
                // 这个任务创建并启动三个子任务
                var childTasks = new[] {
                    tf.StartNew(() => Sum(cts.Token, 10000)),
                    tf.StartNew(() => Sum(cts.Token, 20000))
                    tf.StartNew(() => Sum(cts.Token, Int32.MaxValue))  // 太大，抛出 OverflowException异常
                };
 
                // 如果子任务抛出异常蛮久取消其余子任务
                for (Int32 task = 0; task < childTasks.Length; task++)
                    childTasks[task].ContinueWith(t => cts.Cancel(), TaskContinuationOptions.OnlyOnFaulted);
 
                // 所有子任务完成后，从未出错/未取消的任务返回的值，
                // 然后将最大值传给另一个任务来显示结果
                tf.ContinueWhenAll(childTasks,
                   completedTasks => completedTasks.Where(t => !t.IsFaulted && !t.IsCanceled).Max(t => t.Result),
                   CancellationToken.None)
                   .ContinueWith(t => Console.WriteLine("The maximum is: " + t.Result),
                      TaskContinuationOptions.ExecuteSynchronously).Wait();
            });
 
            // 子任务完成后，也显示任何未处理的异常
            parent.ContinueWith(p =>
            {
                // 将所有文本放到一个 StringBuilder 中并只调用 Console.WrteLine 一次
                // 因为这个任务可能和上面任务并行执行，而我不希望任务的输出变得不连续
                StringBuilder sb = new StringBuilder("The following exception(s) occurred:" + Environment.NewLine);
                foreach (var e in p.Exception.Flatten().InnerExceptions)
                    sb.AppendLine("   " + e.GetType().ToString());
                Console.WriteLine(sb.ToString());
            }, TaskContinuationOptions.OnlyOnFaulted);
 
            // 启动父任务，便于它启动子任务
            parent.Start();