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(0, 100000).ToList();
            PartitionByPartCount(datas,5);
            PartitionByPartSize(datas,100);
        }

        private static void PartitionByPartCount<T>(IList<T> datas, int partCount)
        {
            var partSize = (int)Math.Ceiling(datas.Count / (double)partCount);
            var partitioner = Partitioner.Create(0, 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(0, 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(0, 10000000).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[5000];
            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 > 0) 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 < 3)
                        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 > 0) throw new AggregateException(exceptions);
        }
        #endregion
    }
}