C#学习笔记13

public class ThreadApply
{
    public void TaskCreate()
    {
        int times = 1000;
        Task task = new Task(() =>
          {
              for (int i = 0; i < times; i++)
              {
                  Console.Write("-");
              }
          });
        task.Start();
        for (int i = 0; i < times; i++)
        {
            Console.Write(".");
        }
        task.Wait();
    }

    public void TaskStaticCreate()
    {
        Task<string> task = Task.Factory.StartNew(() =>
        {
            Thread.Sleep(100);
            return "主神";
        });
        foreach (char busySymbol in Utility.BusySymbols())
        {
            if (task.IsCompleted)
            {
                Console.Write(‘\b‘);
                break;
            }
            Console.Write(busySymbol);
        }
        Console.WriteLine();
        Console.WriteLine(task.Result);
        Console.WriteLine(task.Status);
        Trace.Assert(task.IsCompleted);
    }

    public void TaskAsyncState()
    {
        Man man = new Man() { Name = "主神", Age = 1 };
        Task task = Task.Factory.StartNew((_man) =>
        {
            Man tempMan = (Man)_man;
            Console.WriteLine("执行前{0}", tempMan);
            tempMan.Name = "诸神";
            tempMan.Age += 10;
            Console.WriteLine("执行后{0}", tempMan);
        }, man);
        task.Wait();
        Console.WriteLine("原始{0}，异步后{1}", man, task.AsyncState);
    }

    public void TaskContinueWith()
    {
        Task<string> task = Task<string>.Factory.StartNew(() =>
        {
            Console.WriteLine("主任务");
            Thread.Sleep(200);
            return "红星";
        });
        Task faultedTask = task.ContinueWith((antecedentTask) =>
        {
            Trace.Assert(antecedentTask.IsFaulted);
            Console.WriteLine("Task State: Faulted");
        }, TaskContinuationOptions.OnlyOnFaulted);
        Task cancelTask = task.ContinueWith((antecedentTask) =>
        {
            Trace.Assert(antecedentTask.IsCanceled);
            Console.WriteLine("Task State: Canceled");
        }, TaskContinuationOptions.OnlyOnCanceled);
        Task completedTask = task.ContinueWith((antecedentTask) =>
        {
            Trace.Assert(antecedentTask.IsCompleted);
            Console.WriteLine("Task Result:{0}", antecedentTask.Result);
            Console.WriteLine("Task State: Completed");
        }, TaskContinuationOptions.OnlyOnRanToCompletion);
        completedTask.Wait();//这句代码可以不用，仅仅是为了阻止控制台关闭
    }

    public void TaskException()
    {
        //此处代码的演示了未处理的框架，如何将任务的未处理的异常传回给主线程，注意异常的数据类型是异常集合AggregateException，
        Task task = Task.Factory.StartNew(() => { throw new ApplicationException(); });
        try
        {
            task.Wait();
        }
        catch (AggregateException ex)
        {
            foreach (Exception item in ex.InnerExceptions)
            {
                Console.WriteLine("error : {0}", item.Message);
            }
        }
    }

    public void TaskException2()
    {
        /*Task task = Task.Factory.StartNew(() => { throw new ApplicationException(); });
        Task faultedTask = task.ContinueWith(antecedentTask => { Console.WriteLine("父任务执行失败"); }, TaskContinuationOptions.OnlyOnFaulted);
        faultedTask.Wait();
        if (task.IsFaulted)
        {
            Console.WriteLine("Error: {0}", task.Exception.Message);//task的异常类型为AggregateException
        }*/
        Task task = Task.Factory.StartNew(() => { throw new ApplicationException(); });
        Task faultedTask = task.ContinueWith(antecedentTask =>
        {
            foreach (var item in antecedentTask.Exception.InnerExceptions)
            {
                Console.WriteLine("Error:{0}", item.Message);
            }
            Console.WriteLine("父任务执行失败");
        }, TaskContinuationOptions.OnlyOnFaulted);
        faultedTask.Wait();
    }

    public void TaskCancellationToken()
    {
        string stars = "*".PadRight(50, ‘*‘);
        Console.WriteLine("Push Enter to exit.");
        CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
        Task task = Task.Factory.StartNew(() => Utility.WriteNaturalNumber(cancellationTokenSource.Token), cancellationTokenSource.Token);
        Thread.Sleep(2000);
        Console.WriteLine();
        cancellationTokenSource.Cancel();
        Console.WriteLine(stars);
        task.Wait();
        Console.WriteLine("Task Status: {0}", task.Status);
        //在任务中是正常取消的，所以任务的状态是RanToCompletion。若要状态为Canceled，可是使用CancellationToken.ThrowIfCancellationRequested()方法，报告异常。
    }

    public void ParallelFor()
    {
        Parallel.For(0, 100, (i) =>
        {
            Console.WriteLine("第{0}次,threadId={1}", i, Thread.CurrentThread.ManagedThreadId);
        });
    }

    public void ParallelForeach()
    {
        IEnumerable<string> files = Directory.GetFiles("D:\\", "*.txt", SearchOption.AllDirectories);
        try
        {
            Parallel.ForEach(files, (fileName) =>
            {
                //Encrypt(fileName);
            });
        }
        catch (AggregateException ex)
        {
            foreach (var item in ex.InnerExceptions)
            {
                Console.WriteLine(item.Message);
            }
        }
    }

    public void CancelParallelForeach()
    {
        IEnumerable<string> files = Directory.GetFiles("D:\\", "*.txt", SearchOption.AllDirectories);
        CancellationTokenSource cts = new CancellationTokenSource();
        ParallelOptions parallelOptions = new ParallelOptions() { CancellationToken = cts.Token };
        cts.Token.Register(() => Console.WriteLine("Cancelling..."));
        Console.WriteLine("Push Enter to exit.");
        Task task = Task.Factory.StartNew(() =>
        {
            //注意，在内部，并行循环条件通过IsCancellationRequested属性阻止尚未开始的新迭代开始。
            Parallel.ForEach(files, parallelOptions, (fileName, loopState) =>
             {
                 //Encrypt(fileName);
             });
        });
        Console.ReadLine();
        cts.Cancel();
        Console.WriteLine("---------分割线----------");
        task.Wait();
    }

    public void ParalleEncrypt(List<string> data)
    {
        ParallelQuery<string> result = data.AsParallel().Select(item => Utility.Encrypt(item));
    }

    public void CancelParallelLinq()
    {
        IEnumerable<int> data = Enumerable.Range(0, 10000);
        CancellationTokenSource cts = new CancellationTokenSource();
        Console.WriteLine("Push Enter to exit.");
        Task task = Task.Factory.StartNew(() =>
        {
            data.AsParallel().WithCancellation(cts.Token).Select(item =>
            {
                Thread.Sleep(100);//模拟损耗的时间
                return item >> 1;
            });
        }, cts.Token);
        /*CancellationToken除了要传给WithCancellation()，还要作为StartNew()的第二个参数传递，这会造成Task.Wait()引发一个AggregateException，
        它的InnerException属性会被设为一个TaskCanceledAException*/
        Console.ReadLine();
        cts.Cancel();
        Console.WriteLine("------------分割线----------------");
        try
        {
            task.Wait();
        }
        catch (AggregateException ex)
        {
            foreach (Exception item in ex.InnerExceptions)
            {
                Console.WriteLine(item.Message);
            }
        }
    }

    public void AppDomainException()
    {
        try
        {
            AppDomain.CurrentDomain.UnhandledException += Utility.OnUnHandledException;
            ThreadPool.QueueUserWorkItem(state => { throw new Exception("不可饶恕"); });
            Thread.Sleep(3000);
            Console.WriteLine("Still Running...");
        }
        finally
        {
            Console.WriteLine("Exiting....");
        }
    }

    public class Man
    {
        public string Name { get; set; }
        public int Age { get; set; }
        public override string ToString()
        {
            return string.Format("Name:{0},Age:{1}", Name, Age);
        }
    }
}

public class Utility
{
    public static IEnumerable<char> BusySymbols()
    {
        string busySymbols = @"-\|/-\|/";
        int next = 0;
        while (true)
        {
            yield return busySymbols[next];
            next = ++next % busySymbols.Length;
            yield return ‘\b‘;
        }
    }
    /// <summary>
        /// 输出自然数
        /// </summary>
        /// <param name="cancellationToken">取消标记</param>
    public static void WriteNaturalNumber(CancellationToken cancellationToken)
    {
        int num = 0;
        while (!cancellationToken.IsCancellationRequested)
        {
            Thread.Sleep(100);
            Console.Write("{0},", num++);
        }
    }

    public static string Encrypt(string text)
    {
        throw new NotImplementedException();
    }

    public static void OnUnHandledException(object sender, UnhandledExceptionEventArgs e)
    {
        Exception exception = (Exception)e.ExceptionObject;
        Console.WriteLine("Error {0}:{1}  -->{2}", exception.GetType().Name, exception.Message, exception.InnerException.Message);
    }
}