C#-Parallel

 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
     }
 }