C#-Task任务取消

static void Main(string[] args)
        {

            var tasks = new List<Task<int>>();
            CancellationTokenSource source = new CancellationTokenSource();
            CancellationToken token = source.Token;
            // Define a delegate that prints and returns the system tick count
            Func<object, int> action = (object obj) =>
            {
                int i = (int)obj;

                // Make each thread sleep a different time in order to return a different tick count
                Thread.Sleep(i * 100);

                // The tasks that receive an argument between 2 and 5 throw exceptions
                if (2 <= i && i <= 5)
                {
                    if (token.IsCancellationRequested)
                        token.ThrowIfCancellationRequested();
                    //source.Cancel();
                    // if (token.IsCancellationRequested)
                    //   
                    // throw new AggregateException("SIMULATED EXCEPTION");
                }

                int tickCount = Environment.TickCount;
                Console.WriteLine("Task={0}, i={1}, TickCount={2}, Thread={3}", Task.CurrentId, i, tickCount, Thread.CurrentThread.ManagedThreadId);

                return tickCount;
            };

            // Construct started tasks
            for (int i = 0; i < 10; i++)
            {
                int index = i;
                //tasks.Add(Task<int>.Factory.StartNew(action, index, source.Token));
                if (2 <= i && i <= 5)
                {
                    tasks.Add(Task<int>.Factory.StartNew(action, index, source.Token));
                }
                else {
                    tasks.Add(Task<int>.Factory.StartNew(action, index));
                }
              
            }

            try
            {
                // Wait for all the tasks to finish.
                // 
               // 
                Task.WaitAny(tasks.ToArray());
                source.Cancel();
                Thread.Sleep(5000);
           
                foreach (var t in tasks)
                {
                    Console.WriteLine("   Task {0}: {1}", t.Id, t.Status);
                }
                // We should never get to this point
                Console.WriteLine("WaitAll() has not thrown exceptions. THIS WAS NOT EXPECTED.");
            }
            catch (AggregateException e)
            {
                foreach (Exception ea in e.InnerExceptions)
                {
                    if (ea is TaskCanceledException)
                        Console.WriteLine("Unable to compute mean: {0}",
                                          ((TaskCanceledException)ea).Message);
                    else
                        Console.WriteLine("Exception: " + e.GetType().Name);
                }
                    Console.WriteLine("
The following exceptions have been thrown by WaitAll(): (THIS WAS EXPECTED)");
                for (int j = 0; j < e.InnerExceptions.Count; j++)
                {
                    Console.WriteLine("
-------------------------------------------------
{0}", e.InnerExceptions[j].ToString());
                }
            }
            finally
            {
                source.Dispose();
            }
        }