using System;

 using System.Collections.Concurrent;

 using System.Collections.Generic;

 using System.Linq;

 using System.Threading;

 using System.Threading.Tasks;

 namespace Try

 {

     public class ParallelTest

     {

         #region 分区块并行执行

         public static void TestPartition()

         {

             var datas = Enumerable.Range(, ).ToList();

             PartitionByPartCount(datas,);

             PartitionByPartSize(datas,);

         }

         private static void PartitionByPartCount<T>(IList<T> datas, int partCount)

         {

             var partSize = (int)Math.Ceiling(datas.Count / (double)partCount);

             var partitioner = Partitioner.Create(, datas.Count, partSize);

             Parallel.ForEach(partitioner, (part, state, partIndex) => {

                 for (int index = part.Item1; index < part.Item2; index++)

                 {

                     Console.WriteLine($"partIndex:{partIndex},index:{index},data:{datas[index]}");

                 }

             });

         }

         private static void PartitionByPartSize<T>(IList<T> datas, int partSize)

         {

             var partitioner = Partitioner.Create(, datas.Count, partSize);

             Parallel.ForEach(partitioner, (part, state, partIndex) => {

                 for (int index = part.Item1; index < part.Item2; index++)

                 {

                     Console.WriteLine($"partIndex:{partIndex},index:{index},data:{datas[index]}");

                 }

             });

         }

         #endregion

         #region 取消Parallel

         public static void TestCancel()

         {

             int[] nums = Enumerable.Range(, ).ToArray();

             CancellationTokenSource cts = new CancellationTokenSource();

             // Use ParallelOptions instance to store the CancellationToken

             ParallelOptions po = new ParallelOptions();

             po.CancellationToken = cts.Token;

             po.MaxDegreeOfParallelism = System.Environment.ProcessorCount;

             Console.WriteLine("Press any key to start. Press 'c' to cancel.");

             Console.ReadKey();

             // Run a task so that we can cancel from another thread.

             Task.Factory.StartNew(() =>

             {

                 if (Console.ReadKey().KeyChar == 'c')

                     cts.Cancel();

                 Console.WriteLine("press any key to exit");

             });

             try

             {

                 Parallel.ForEach(nums, po, (num) =>

                 {

                     double d = Math.Sqrt(num);

                     Console.WriteLine("{0} on {1}", d, Thread.CurrentThread.ManagedThreadId);

                     po.CancellationToken.ThrowIfCancellationRequested();

                 });

             }

             catch (OperationCanceledException e)

             {

                 Console.WriteLine(e.Message);

             }

             finally

             {

                 cts.Dispose();

             }

             Console.ReadKey();

         }

         #endregion

         #region 异常处理

         public static void TestException()

         {

             // Create some random data to process in parallel.

             // There is a good probability this data will cause some exceptions to be thrown.

             byte[] data = new byte[];

             Random r = new Random();

             r.NextBytes(data);

             try

             {

                 ProcessDataInParallel(data);

             }

             catch (AggregateException ae)

             {

                 var ignoredExceptions = new List<Exception>();

                 // This is where you can choose which exceptions to handle.

                 foreach (var ex in ae.Flatten().InnerExceptions)

                 {

                     if (ex is ArgumentException)

                         Console.WriteLine(ex.Message);

                     else

                         ignoredExceptions.Add(ex);

                 }

                 if (ignoredExceptions.Count > ) throw new AggregateException(ignoredExceptions);

             }

             Console.WriteLine("Press any key to exit.");

             Console.ReadKey();

         }

         private static void ProcessDataInParallel(byte[] data)

         {

             // Use ConcurrentQueue to enable safe enqueueing from multiple threads.

             var exceptions = new ConcurrentQueue<Exception>();

             // Execute the complete loop and capture all exceptions.

             Parallel.ForEach(data, d =>

             {

                 try

                 {

                     // Cause a few exceptions, but not too many.

                     if (d < )

                         throw new ArgumentException($"Value is {d}. Value must be greater than or equal to 3.");

                     else

                         Console.Write(d + " ");

                 }

                 // Store the exception and continue with the loop.

                 catch (Exception e)

                 {

                     exceptions.Enqueue(e);

                 }

             });

             Console.WriteLine();

             // Throw the exceptions here after the loop completes.

             if (exceptions.Count > ) throw new AggregateException(exceptions);

         }

         #endregion

     }

 }