Task2

这篇文章是第一篇Task文章的继续，比较啰嗦，本人也是靠msdn文档来学习的；

一、罗列一些属性

1、TaskCanceledException 类  ，表示一个用于告知任务取消的异常。https://msdn.microsoft.com/zh-cn/library/system.threading.tasks.taskcanceledexception(v=vs.110).aspx

2、TaskContinuationOptions  Flag枚举，创建的任务指定行为，https://msdn.microsoft.com/zh-cn/library/system.threading.tasks.taskcontinuationoptions(v=vs.110).aspx

3、TaskCreationOptions Flag枚举,指定用于控制任务的创建和执行的可选行为的标志。https://msdn.microsoft.com/zh-cn/library/system.threading.tasks.taskcreationoptions(v=vs.110).aspx

4、TaskStatus 枚举，表示 Task的生命周期中的当前阶段。https://msdn.microsoft.com/zh-cn/library/system.threading.tasks.taskstatus(v=vs.110).aspx

二、UnWrap  创建一个代理 Task 表示异步操作的 TryExecuteTaskInline。展开，解包,如返回值是Task<Task<int>>==>Task<int>

// Invoking individual tasks is straightforward
            Task<int> t1 = RemoteIncrement(0);
            Console.WriteLine("Started RemoteIncrement(0)");

            // Chain together the results of (simulated) remote operations.
            // The use of Unwrap() instead of .Result below prevents this thread from blocking while setting up this continuation chain.
            Task<int> t2 = RemoteIncrement(4)
                // RemoteIncrement() returns Task<int> so no unwrapping is needed for the first continuation.
                .ContinueWith(t => RemoteIncrement(t.Result))
                // ContinueWith() returns Task<Task<int>>. Therefore unwrapping is needed.
                .Unwrap().ContinueWith(t => RemoteIncrement(t.Result))    
                .Unwrap().ContinueWith(t => RemoteIncrement(t.Result))    // and on it goes...
                .Unwrap();
            Console.WriteLine("Started RemoteIncrement(...(RemoteIncrement(RemoteIncrement(4))...)");

            try
            {
                t1.Wait();
                Console.WriteLine("Finished RemoteIncrement(0)
");

                t2.Wait();
                Console.WriteLine("Finished RemoteIncrement(...(RemoteIncrement(RemoteIncrement(4))...)");
            }
            catch (AggregateException e)
            {
                Console.WriteLine("A task has thrown the following (unexpected) exception:
{0}", e);
            }

            Console.ReadKey();
//结果：
//Started RemoteIncrement(0)
//Started RemoteIncrement(...(RemoteIncrement(RemoteIncrement(4))...)
//Thread=10, Next=1
//Finished RemoteIncrement(0)

//Thread=11, Next=5
//Thread=12, Next=6
//Thread=11, Next=7
//Thread=10, Next=8
//Finished RemoteIncrement(...(RemoteIncrement(RemoteIncrement(4))...)

三、TaskCompletionSource  

TaskCompletionSource 表示未绑定到委托的 Task<TResult> 的制造者方，并通过 Task 属性提供对使用者方的访问值并且通过TrySetResult方法可以设置Task的返回值。         task.IsFaulted 只有在ContinueWith里面才会等待任务执行完

 static public class Connector
    {
        /// <summary>
        /// begin connect
        /// </summary>
        /// <param name="endPoint"></param>
        /// <exception cref="ArgumentNullException">endPoint is null</exception>
        static public Task<Socket> Connect(EndPoint endPoint)
        {
            if (endPoint == null) throw new ArgumentNullException("endPoint");

            var source = new TaskCompletionSource<Socket>();
            var socket = new Socket(endPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);

            var e = new SocketAsyncEventArgs();
            e.UserToken = new Tuple<TaskCompletionSource<Socket>, Socket>(source, socket);
            e.RemoteEndPoint = endPoint;
            e.Completed += OnCompleted;

            bool completed = true;
            try { completed = socket.ConnectAsync(e); }
            catch (Exception ex) { source.TrySetException(ex); }
            if (!completed) ThreadPool.QueueUserWorkItem(_ => OnCompleted(null, e));

            return source.Task;
        }
        /// <summary>
        /// connect completed
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        static private void OnCompleted(object sender, SocketAsyncEventArgs e)
        {
            var t = e.UserToken as Tuple<TaskCompletionSource<Socket>, Socket>;
            var source = t.Item1;
            var socket = t.Item2;
            var error = e.SocketError;

            e.UserToken = null;
            e.Completed -= OnCompleted;
            e.Dispose();

            if (error != SocketError.Success)
            {
                socket.Close();
                source.TrySetException(new SocketException((int)error));
                return;
            }

            source.TrySetResult(socket);
        }
    }

  TaskCompletionSource<int> tcs1 = new TaskCompletionSource<int>();
            Task<int> t1 = tcs1.Task;
            // Start a background task that will complete tcs1.Task
            Task.Factory.StartNew(() =>
            {
                Thread.Sleep(2000);
                tcs1.TrySetResult(15);
            });
            // The attempt to get the result of t1 blocks the current thread until the completion source gets signaled.
            // It should be a wait of ~2000 ms.
            Stopwatch sw = Stopwatch.StartNew();
            int result = t1.Result;//获取结果的时候必须等待操作完成
            sw.Stop();
            Console.WriteLine("(ElapsedTime={0}): t1.Result={1} (expected 15) ", sw.ElapsedMilliseconds, result);

            // Alternatively, an exception can be manually set on a TaskCompletionSource.Task
            TaskCompletionSource<int> tcs2 = new TaskCompletionSource<int>();
            Task<int> t2 = tcs2.Task;

            // Start a background Task that will complete tcs2.Task with an exception
            Task.Factory.StartNew(() =>
            {
                Thread.Sleep(1000);

                //tcs2.SetException(new InvalidOperationException("SIMULATED EXCEPTION"));
                //出现了异常,已被系统处理,但是下面获取Result属性的时候肯定出错
                tcs2.TrySetException(new InvalidOperationException("SIMULATED EXCEPTION"));
            });

            // The attempt to get the result of t2 blocks the current thread until the completion source gets signaled with either a result or an exception.
            // In either case it should be a wait of ~1000 ms.
            //sw = Stopwatch.StartNew();
            //解决异常1  调用 Task 的 Wait或者 Task.Result 方法时使用 try-catch 捕获异常：
            //try
            //{
            //    result = t2.Result;//因为TrySetException,获取结果会抛错

            //    Console.WriteLine("t2.Result succeeded. THIS WAS NOT EXPECTED.");
            //}
            //catch (AggregateException e)
            //{
            //    Console.Write("(ElapsedTime={0}): ", sw.ElapsedMilliseconds);
            //    Console.WriteLine("The following exceptions have been thrown by t2.Result: (THIS WAS EXPECTED)");
            //    for (int j = 0; j < e.InnerExceptions.Count; j++)
            //    {
            //        Console.WriteLine("
-------------------------------------------------
{0}", e.InnerExceptions[j].ToString());
            //    }
            //}

            //解决异常2 在 Task 的 ContinueWith 方法中读取 Task 的 IsFaulted 属性是否出错：
            t2.ContinueWith(task =>
            {
                //task是上一个任务的结果, task.IsFaulted是判断有没有错误;如果不在ContinueWith里面或者在外面不用T2.Wait执行完,结果可能不
                //正确,因为IsFaulted属性不会阻塞线程的, 直接判断任务代码还没出现错误都是false,没有出错
                if (task.IsFaulted)
                {
                    Console.WriteLine(task.Exception.GetBaseException());
                    Console.WriteLine("出现了异常,已被系统处理,但是获取Result属性的时候肯定出错");
                    Console.WriteLine(task.Result);
                }
                else
                {
                    //没有异常才获取结果,要不然会抛错
                    Console.WriteLine(task.Result);
                }
            });
            Console.ReadKey();

四、TaskFactory

在大多数情况下，我们无需实例化一个新 TaskFactory 实例。 相反，可以使用 Task.Factory 属性，它返回一个工厂对象，将使用默认值。 然后可以调用其方法来启动新任务或定义任务延续。

//想等待多个任务就用Task数组,使用Task.Await或者Task.Factory.ContinueWhenAll()

//创建一个任务，在数组中的任务之一通过调用完成后开始 ContinueWhenAny 方法。
//创建一个任务，在数组中的所有任务已都完成通过调用开始 ContinueWhenAll 方法。

//TaskFactory 类
Task[] tasks = new Task[2];
            String[] files = null;
            String[] dirs = null;
            String docsDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
            tasks[0] = Task.Factory.StartNew(() => { Thread.Sleep(3000); files = Directory.GetFiles(docsDirectory); });
            tasks[1] = Task.Factory.StartNew(() => dirs = Directory.GetDirectories(docsDirectory));
            Console.WriteLine(files.Length);//不会等待的，报空异常
            Task.Factory.ContinueWhenAll(tasks, completedTasks =>
            {
                Console.WriteLine("{0} contains: ", docsDirectory);
                Console.WriteLine("   {0} subdirectories", dirs.Length);
                Console.WriteLine("   {0} files", files.Length);
            });
            Console.ReadKey();

            Task<string[]>[] tasks = new Task<string[]>[2];
            string docsDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
            tasks[0] = Task<string[]>.Factory.StartNew(() => Directory.GetFiles(docsDirectory));
            tasks[1] = Task<string[]>.Factory.StartNew(() => Directory.GetDirectories(docsDirectory));
            Task.Factory.ContinueWhenAll(tasks, completedTasks =>
            {
                Console.WriteLine("{0} contains: ", docsDirectory);
                Console.WriteLine("   {0} subdirectories", tasks[1].Result.Length);
                Console.WriteLine("   {0} files", tasks[0].Result.Length);
            });
            Console.ReadKey();