public static void Main()
        {
            // Start the HandleFile method.
            Task<int> task = HandleFileAsync();//可以看作是一个耗时任务

            // Control returns here before HandleFileAsync returns.
            // ... Prompt the user.
            Console.WriteLine("Please wait patiently " +
                "while I do something important.");

            // Do something at the same time as the file is being read.
            string line = Console.ReadLine();
            Console.WriteLine("You entered (asynchronous logic): " + line);

            // Wait for the HandleFile task to complete.
            // ... Display its results.
            task.Wait();//有调用.result时，这里可以省略。在没有调用.result时，一定要.wait()下，这个话题涉及到当task运行出现异常时：为什么要调用Wait或者Result？
或者一直不查询Task的Exception属性？你的代码就永远注意不到这个异常的发生，如果不能捕捉到这个异常，垃圾回收时，
抛出AggregateException，进程就会立即终止，这就是“牵一发动全身”，莫名其妙程序就自己关掉了
            var x = task.Result;//其实在用Result的时候，内部会调用Wait
            Console.WriteLine("Count: " + x);

            Console.WriteLine("[DONE]");
            Console.ReadLine();
        }

        static async Task<int> HandleFileAsync()//async与下文的await是成对出现，否则不能实现真正的异步，而是同步执行。
        {
            string file = @"C:\enable1.txt";//在这个文档中输入几个字符和输入1MB字符，最终输出结果会有不同，能很好的展示异步调用方式
            Console.WriteLine("HandleFile enter");
            int count = 0;

            // Read in the specified file.
            // ... Use async StreamReader method.
            using (StreamReader reader = new StreamReader(file))
            {
                string v = await reader.ReadToEndAsync();
                //string v = reader.ReadToEnd();

                // ... Process the file data somehow.
                count += v.Length;

                // ... A slow-running computation.
                //     Dummy code.
                for (int i = 0; i < 10000; i++)
                {
                    int x = v.GetHashCode();
                    if (x == 0)
                    {
                        count--;
                    }
                }
            }
            Console.WriteLine("HandleFile exit");
            return count;
        }

  static void Main()
        {
            // Call async method 10 times.
            for (int i = 0; i < 10; i++)
            {
                Run2Methods(i);
            }
            // The calls are all asynchronous, so they can end at any time.
            Console.ReadLine();
        }

        static async void Run2Methods(int count)
        {
            // Run a Task that calls a method, then calls another method with ContinueWith.
            int result = await Task.Run(() => GetSum(count))
                .ContinueWith(task => MultiplyNegative1(task));
            Console.WriteLine("Run2Methods result: " + result);
        }

        static int GetSum(int count)
        {
            // This method is called first, and returns an int.
            int sum = 0;
            for (int z = 0; z < count; z++)
            {
                sum += (int)Math.Pow(z, 2);
            }
            return sum;
        }

        static int MultiplyNegative1(Task<int> task)
        {
            // This method is called second, and returns a negative int.
            return task.Result * -1;
        }

  static void Main(string[] args)
        {
            using (var cts = new CancellationTokenSource())
            {
                Task task = new Task(() => { LongRunningTask(cts.Token); });
                task.Start();
                Console.WriteLine("Operation Performing...");
                if (Console.ReadKey().Key == ConsoleKey.C)
                {
                    Console.WriteLine("Cancelling..");
                    cts.Cancel();
                }
                Console.Read();
            }
        }
        private static void LongRunningTask(CancellationToken token)
        {
            for (int i = 0; i < 10000000; i++)
            {
                if (token.IsCancellationRequested)
                {
                    break;
                }
                else
                {
                    Console.WriteLine(i);
                }
            }
        }