C# Task.Parallel

此示例演示了使用多种语言构造实现并行循环的几种方法。

using System.Threading.Tasks;   
class Test
{
    static int N = 1000;

    static void TestMethod()
    {
        // Using a named method.
        Parallel.For(0, N, Method2);

        // Using an anonymous method.
        Parallel.For(0, N, delegate(int i)
        {
            // Do Work.
        });

        // Using a lambda expression.
        Parallel.For(0, N, i =>
        {
            // Do Work.
        });
    }

    static void Method2(int i)
    {
        // Do work.
    }
}

也有其他的循环

For(Int32, Int32, Action<Int32,ParallelLoopState>)	执行 for 循环，其中可能会并行运行迭代，而且可以监视和操作循环的状态。
For(Int32, Int32, Action<Int32>)	执行 for 循环，其中可能会并行运行迭代。
For(Int32, Int32, ParallelOptions, Action<Int32,ParallelLoopState>)	执行 for 循环，其中可能会并行运行迭代，而且可以配置循环选项，可以监视和操作循环的状态。
For(Int32, Int32, ParallelOptions, Action<Int32>)	执行 for 循环，其中可能会并行运行迭代，而且可以配置循环选项。
For(Int64, Int64, Action<Int64,ParallelLoopState>)	执行具有 64 位索引的 for 循环，其中可能会并行运行迭代，而且可以监视和操作循环的状态。
For(Int64, Int64, Action<Int64>)	执行具有 64 位索引的 for 循环，其中可能会并行运行迭代，而且可以监视和操作循环的状态。
For(Int64, Int64, ParallelOptions, Action<Int64,ParallelLoopState>)	执行具有 64 位索引的 for 循环，其中可能会并行运行迭代，而且可以配置循环选项，可以监视和操作循环的状态。
For(Int64, Int64, ParallelOptions, Action<Int64>)	执行具有 64 位索引的 for 循环，其中可能会并行运行迭代，而且可以配置循环选项。
For<TLocal>(Int32, Int32, Func<TLocal>, Func<Int32,ParallelLoopState,TLocal,TLocal>, Action<TLocal>)	执行具有线程本地数据的 for 循环，其中可能会并行运行迭代，而且可以监视和操作循环的状态。
For<TLocal>(Int32, Int32, ParallelOptions, Func<TLocal>, Func<Int32,ParallelLoopState,TLocal,TLocal>, Action<TLocal>)	执行具有线程本地数据的 for 循环，其中可能会并行运行迭代，而且可以配置循环选项，可以监视和操作循环的状态。
For<TLocal>(Int64, Int64, Func<TLocal>, Func<Int64,ParallelLoopState,TLocal,TLocal>, Action<TLocal>)	执行具有 64 位索引和线程本地数据的 for 循环，其中可能会并行运行迭代，而且可以监视和操作循环的状态。
For<TLocal>(Int64, Int64, ParallelOptions, Func<TLocal>, Func<Int64,ParallelLoopState,TLocal,TLocal>, Action<TLocal>)	执行具有 64 位索引和线程本地数据的 for 循环，其中可能会并行运行迭代，而且可以配置循环选项，可以监视和操作循环的状态。
ForEach<TSource,TLocal>(IEnumerable<TSource>, Func<TLocal>, Func<TSource,ParallelLoopState,Int64,TLocal,TLocal>, Action<TLocal>)	执行具有线程本地数据的 foreach（在 Visual Basic 中为 For Each）操作，其中在 IEnumerable 上可能会并行运行迭代，而且可以监视和操作循环的状态。
ForEach<TSource,TLocal>(IEnumerable<TSource>, Func<TLocal>, Func<TSource,ParallelLoopState,TLocal,TLocal>, Action<TLocal>)	执行具有线程本地数据的 foreach（在 Visual Basic 中为 For Each）操作，其中在 IEnumerable 上可能会并行运行迭代，而且可以监视和操作循环的状态。
ForEach<TSource,TLocal>(IEnumerable<TSource>, ParallelOptions, Func<TLocal>, Func<TSource,ParallelLoopState,Int64,TLocal,TLocal>, Action<TLocal>)	执行具有线程本地数据和 64 位索引的 foreach（在 Visual Basic 中为 For Each）操作，其中在 IEnumerable 上可能会并行运行迭代，而且可以配置循环选项，可以监视和操作循环的状态。
ForEach<TSource,TLocal>(IEnumerable<TSource>, ParallelOptions, Func<TLocal>, Func<TSource,ParallelLoopState,TLocal,TLocal>, Action<TLocal>)	执行具有线程本地数据的 foreach（在 Visual Basic 中为 For Each）操作，其中在 IEnumerable 上可能会并行运行迭代，而且可以配置循环选项，可以监视和操作循环的状态。
ForEach<TSource,TLocal>(OrderablePartitioner<TSource>, Func<TLocal>, Func<TSource,ParallelLoopState,Int64,TLocal,TLocal>, Action<TLocal>)	执行具有线程本地数据的 foreach（在 Visual Basic 中为 For Each）操作，其中在 OrderablePartitioner<TSource> 上可能会并行运行迭代，而且可以配置循环选项，可以监视和操作循环的状态。
ForEach<TSource,TLocal>(OrderablePartitioner<TSource>, ParallelOptions, Func<TLocal>, Func<TSource,ParallelLoopState,Int64,TLocal,TLocal>, Action<TLocal>)	执行具有 64 位索引和线程本地数据的 foreach（在 Visual Basic 中为 For Each）操作，其中在 OrderablePartitioner<TSource> 上可能会并行运行迭代，而且可以配置循环选项，可以监视和操作循环的状态。
ForEach<TSource,TLocal>(Partitioner<TSource>, Func<TLocal>, Func<TSource,ParallelLoopState,TLocal,TLocal>, Action<TLocal>)	执行具有线程本地数据的 foreach（在 Visual Basic 中为 For Each）操作，其中在 Partitioner 上可能会并行运行迭代，而且可以监视和操作循环的状态。
ForEach<TSource,TLocal>(Partitioner<TSource>, ParallelOptions, Func<TLocal>, Func<TSource,ParallelLoopState,TLocal,TLocal>, Action<TLocal>)	执行具有线程本地数据的 foreach（在 Visual Basic 中为 For Each）操作，其中在 Partitioner 上可能会并行运行迭代，而且可以配置循环选项，可以监视和操作循环的状态。
ForEach<TSource>(IEnumerable<TSource>, Action<TSource,ParallelLoopState,Int64>)	执行具有 64 位索引的 foreach（在 Visual Basic 中为 For Each）操作，其中在 IEnumerable 上可能会并行运行迭代，而且可以监视和操作循环的状态。
ForEach<TSource>(IEnumerable<TSource>, Action<TSource,ParallelLoopState>)	执行 foreach（在 Visual Basic 中为 For Each）操作，其中在 IEnumerable 中可能会并行运行迭代，而且可以监视和操作循环的状态。
ForEach<TSource>(IEnumerable<TSource>, Action<TSource>)	执行 foreach（在 Visual Basic 中为 For Each）操作，其中在 IEnumerable 上可能会并行运行迭代。
ForEach<TSource>(IEnumerable<TSource>, ParallelOptions, Action<TSource,ParallelLoopState,Int64>)	执行具有 64 位索引的 foreach（在 Visual Basic 中为 For Each）操作，其中在 IEnumerable 上可能会并行运行迭代，而且可以配置循环选项，可以监视和操作循环的状态。
ForEach<TSource>(IEnumerable<TSource>, ParallelOptions, Action<TSource,ParallelLoopState>)	执行 foreach（在 Visual Basic 中为 For Each）操作，其中在 IEnumerable 中可能会并行运行迭代，而且可以配置循环选项，可以监视和操作循环的状态。
ForEach<TSource>(IEnumerable<TSource>, ParallelOptions, Action<TSource>)	执行 foreach（在 Visual Basic 中为 For Each）操作，其中在 IEnumerable 中可能会并行运行迭代，而且可以匹配配置循环选项。
ForEach<TSource>(OrderablePartitioner<TSource>, Action<TSource,ParallelLoopState,Int64>)	执行 foreach（在 Visual Basic 中为 For Each）操作，其中在 OrderablePartitioner<TSource> 中可能会并行运行迭代，而且可以监视和操作循环的状态。
ForEach<TSource>(OrderablePartitioner<TSource>, ParallelOptions, Action<TSource,ParallelLoopState,Int64>)	执行 foreach（在 Visual Basic 中为 For Each）操作，其中在 OrderablePartitioner<TSource> 中可能会并行运行迭代，而且可以配置循环选项，可以监视和操作循环的状态。
ForEach<TSource>(Partitioner<TSource>, Action<TSource,ParallelLoopState>)	执行 foreach（在 Visual Basic 中为 For Each）操作，其中在 Partitioner 中可能会并行运行迭代，而且可以监视和操作循环的状态。
ForEach<TSource>(Partitioner<TSource>, Action<TSource>)	执行 foreach（在 Visual Basic 中为 For Each）操作，其中在 Partitioner 上可能会并行运行迭代。
ForEach<TSource>(Partitioner<TSource>, ParallelOptions, Action<TSource,ParallelLoopState>)	执行 foreach（在 Visual Basic 中为 For Each）操作，其中在 Partitioner 中可能会并行运行迭代，而且可以配置循环选项，可以监视和操作循环的状态。
ForEach<TSource>(Partitioner<TSource>, ParallelOptions, Action<TSource>)	执行 foreach（在 Visual Basic 中为 For Each）操作，其中在 Partitioner 中可能会并行运行迭代，而且可以配置循环选项。
ForEachAsync<TSource>(IAsyncEnumerable<TSource>, CancellationToken, Func<TSource,CancellationToken,ValueTask>)	对迭代并行运行 的每个 操作执行一个 IEnumerable<T> 。
ForEachAsync<TSource>(IAsyncEnumerable<TSource>, Func<TSource,CancellationToken,ValueTask>)	对迭代并行运行 的每个 操作执行一个 IEnumerable<T> 。
ForEachAsync<TSource>(IAsyncEnumerable<TSource>, ParallelOptions, Func<TSource,CancellationToken,ValueTask>)	对迭代并行运行 的每个 操作执行一个 IEnumerable<T> 。
ForEachAsync<TSource>(IEnumerable<TSource>, CancellationToken, Func<TSource,CancellationToken,ValueTask>)	对迭代并行运行 的每个 操作执行一个 IEnumerable<T> 。
ForEachAsync<TSource>(IEnumerable<TSource>, Func<TSource,CancellationToken,ValueTask>)	对迭代并行运行 的每个 操作执行一个 IEnumerable<T> 。
ForEachAsync<TSource>(IEnumerable<TSource>, ParallelOptions, Func<TSource,CancellationToken,ValueTask>)	对迭代并行运行 的每个 操作执行一个 IEnumerable<T> 。
Invoke(Action[])	尽可能并行执行提供的每个操作。
Invoke(ParallelOptions, Action[])	执行所提供的每个操作，而且尽可能并行运行，除非用户取消了操作。

常用的几个方法:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

    class ParallelInvokeDemo
    {

        // Demonstrated features:
        //         Parallel.Invoke()
        // Expected results:
        //         The threads on which each task gets executed may be different.
        //        The thread assignments may be different in different executions.
        //        The tasks may get executed in any order.
        // Documentation:
        //        http://msdn.microsoft.com/library/dd783942(VS.100).aspx
        static void Main()
        {
            try
            {
                Parallel.Invoke(
                    BasicAction,    // Param #0 - static method
                    () =>            // Param #1 - lambda expression
                    {
                        Console.WriteLine("Method=beta, Thread={0}", Thread.CurrentThread.ManagedThreadId);
                    },
                    delegate()        // Param #2 - in-line delegate
                    {
                        Console.WriteLine("Method=gamma, Thread={0}", Thread.CurrentThread.ManagedThreadId);
                    }
                );
            }
            // No exception is expected in this example, but if one is still thrown from a task,
            // it will be wrapped in AggregateException and propagated to the main thread.
            catch (AggregateException e)
            {
                Console.WriteLine("An action has thrown an exception. THIS WAS UNEXPECTED.\n{0}", e.InnerException.ToString());
            }
        }

        static void BasicAction()
        {
            Console.WriteLine("Method=alpha, Thread={0}", Thread.CurrentThread.ManagedThreadId);
        }
    }