Task Class

https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.task?redirectedfrom=MSDN&view=netframework-4.7.2

Task Class

定义

命名空间:

System.Threading.Tasks

Assemblies:

System.Threading.Tasks.dll, mscorlib.dll, netstandard.dll, System.Runtime.dll

表示一个异步操作。

C#复制

public class Task : IAsyncResult, IDisposable

继承

Object

Task

派生

Task<TResult>

实现

IAsyncResult IDisposable

注解

Task类的表示单个操作不会返回一个值，通常以异步方式执行。 Task 对象是一种的中心思想基于任务的异步模式首次引入.NET Framework 4 中。 因为由执行工作Task对象通常以异步方式执行线程池线程上而不是以同步方式在主应用程序线程中，可以使用Status属性，并将IsCanceled， IsCompleted，和IsFaulted属性，以确定任务的状态。 大多数情况下，lambda 表达式用于指定该任务所执行的工作量。

对于返回值的操作，您使用Task<TResult>类。

本节内容：

任务实例化示例 
创建和执行任务 
分离任务创建和执行 
等待一个或多个任务完成 
任务和区域性 
调试程序开发人员

任务实例化

下面的示例创建并执行四个任务。 三个任务执行Action<T>名为的委托action，这样便可以接受类型的自变量Object。 第四个任务执行 lambda 表达式 (Action委托)，它是以内联方式定义的任务创建方法调用中。 每个任务是实例化，并以不同方式运行：

• 任务t1通过调用任务类构造函数，实例化但开始通过调用其Start()方法仅在任务后面t2已开始。

• 任务t2实例化并通过调用单个方法调用中启动TaskFactory.StartNew(Action<Object>, Object)方法。

• 任务t3实例化并通过调用单个方法调用中启动Run(Action)方法。

• 任务t4是以同步方式执行主线程上调用RunSynchronously()方法。

因为任务t4以同步方式，执行其主应用程序线程上执行。 剩余的任务执行异步通常在一个或多个线程池线程上。

C#复制

using System;
using System.Threading;
using System.Threading.Tasks;

class Example
{
    static void Main()
    {
        Action<object> action = (object obj) =>
                                {
                                   Console.WriteLine("Task={0}, obj={1}, Thread={2}",
                                   Task.CurrentId, obj,
                                   Thread.CurrentThread.ManagedThreadId);
                                };

        // Create a task but do not start it.
        Task t1 = new Task(action, "alpha");

        // Construct a started task
        Task t2 = Task.Factory.StartNew(action, "beta");
        // Block the main thread to demonstrate that t2 is executing
        t2.Wait();

        // Launch t1
        t1.Start();
        Console.WriteLine("t1 has been launched. (Main Thread={0})",
                          Thread.CurrentThread.ManagedThreadId);
        // Wait for the task to finish.
        t1.Wait();

        // Construct a started task using Task.Run.
        String taskData = "delta";
        Task t3 = Task.Run( () => {Console.WriteLine("Task={0}, obj={1}, Thread={2}",
                                                     Task.CurrentId, taskData,
                                                      Thread.CurrentThread.ManagedThreadId);
                                   });
        // Wait for the task to finish.
        t3.Wait();

        // Construct an unstarted task
        Task t4 = new Task(action, "gamma");
        // Run it synchronously
        t4.RunSynchronously();
        // Although the task was run synchronously, it is a good practice
        // to wait for it in the event exceptions were thrown by the task.
        t4.Wait();
    }
}
// The example displays output like the following:
//       Task=1, obj=beta, Thread=3
//       t1 has been launched. (Main Thread=1)
//       Task=2, obj=alpha, Thread=4
//       Task=3, obj=delta, Thread=3
//       Task=4, obj=gamma, Thread=1

创建和执行任务

Task 可能在不同的方式中创建实例。 最常用的方法，从开始提供.NET Framework 4.5，是调用静态Run方法。 Run方法提供了简单的方法来启动任务使用默认值，而无需其他参数。 下面的示例使用Run(Action)方法以启动循环，然后显示循环迭代数的任务：

C#复制

using System;
using System.Threading.Tasks;

public class Example
{
   public static async Task Main()
   {
      await Task.Run( () => {
                                  // Just loop.
                                  int ctr = 0;
                                  for (ctr = 0; ctr <= 1000000; ctr++)
                                  {}
                                  Console.WriteLine("Finished {0} loop iterations",
                                                    ctr);
                               } );
   }
}
// The example displays the following output:
//        Finished 1000001 loop iterations

替代方法，并使用最常见方法启动任务.NET Framework 4，是静态TaskFactory.StartNew方法。 Task.Factory属性返回TaskFactory对象。 重载的TaskFactory.StartNew方法允许您指定要传递给任务创建选项和任务计划程序参数。 下面的示例使用TaskFactory.StartNew方法来启动任务。 它是功能上等效于上一示例中的代码。

C#复制

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      Task t = Task.Factory.StartNew( () => {
                                  // Just loop.
                                  int ctr = 0;
                                  for (ctr = 0; ctr <= 1000000; ctr++)
                                  {}
                                  Console.WriteLine("Finished {0} loop iterations",
                                                    ctr);
                               } );
      t.Wait();
   }
}
// The example displays the following output:
//        Finished 1000001 loop iterations

有关更完整示例，请参阅基于任务的异步编程。

分离任务创建和执行

Task类还提供了构造函数对任务进行初始化，但的未计划的执行。 出于性能原因Task.Run或TaskFactory.StartNew方法是用于创建和计划计算任务的首选的机制，但对于创建和计划必须分开的方案，可以使用的构造函数，然后调用Task.Start方法来计划在更高版本时执行的任务。

等待一个或多个任务完成

因为任务通常运行以异步方式在线程池线程上，创建并启动任务的线程将继续执行，一旦该任务已实例化。 在某些情况下，调用线程时，在主应用程序线程应用程序可能会终止之前任何任务才真正开始执行。 其他情况下，应用程序的逻辑可能需要调用线程继续执行，仅当一个或多个任务已完成执行时。 你可以同步调用线程执行异步任务和它启动通过调用Wait方法来等待一个或多个任务完成。

若要等待完成一项任务，可以调用其Task.Wait方法。 调用Wait方法进行阻止调用线程，直到单个类实例已完成执行。

下面的示例调用无参数Wait()方法无条件地等待，直到任务完成。 该任务通过调用来模拟工作Thread.Sleep两秒钟进入睡眠状态的方法。

C#复制

using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static Random rand = new Random();

    static void Main()
    {
        // Wait on a single task with no timeout specified.
        Task taskA = Task.Run( () => Thread.Sleep(2000));
        Console.WriteLine("taskA Status: {0}", taskA.Status);
        try {
          taskA.Wait();
          Console.WriteLine("taskA Status: {0}", taskA.Status);
       }
       catch (AggregateException) {
          Console.WriteLine("Exception in taskA.");
       }
    }
}
// The example displays output like the following:
//     taskA Status: WaitingToRun
//     taskA Status: RanToCompletion

可以有条件地等待任务完成。 Wait(Int32)和Wait(TimeSpan)方法阻止调用线程，直到任务完成或超时间隔结束，具体取决于第一个。 由于下面的示例将启动一个任务，休眠 2 秒，但定义的一秒的超时值，调用线程受到阻止，直到在超时到期之前, 已完成执行的任务。

C#复制

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      // Wait on a single task with a timeout specified.
      Task taskA = Task.Run( () => Thread.Sleep(2000));
      try {
        taskA.Wait(1000);       // Wait for 1 second.
        bool completed = taskA.IsCompleted;
        Console.WriteLine("Task A completed: {0}, Status: {1}",
                         completed, taskA.Status);
        if (! completed)
           Console.WriteLine("Timed out before task A completed.");
       }
       catch (AggregateException) {
          Console.WriteLine("Exception in taskA.");
       }
   }
}
// The example displays output like the following:
//     Task A completed: False, Status: Running
//     Timed out before task A completed.

此外可以通过调用提供的取消标记Wait(CancellationToken)和Wait(Int32, CancellationToken)方法。 如果该令牌的IsCancellationRequested属性是true或变得true虽然Wait执行方法，该方法将引发OperationCanceledException。

在某些情况下，你可能想要等待执行任务的一系列的第一个问题以完成，但不是任务它的护理。 为此，可以调用的重载之一Task.WaitAll方法。 以下示例创建三个任务，其中每个休眠的时间间隔确定由随机数生成器。WaitAny(Task[])方法等待第一个任务完成。 该示例然后显示所有三个任务的状态信息。

C#复制

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      var tasks = new Task[3];
      var rnd = new Random();
      for (int ctr = 0; ctr <= 2; ctr++)
         tasks[ctr] = Task.Run( () => Thread.Sleep(rnd.Next(500, 3000)));

      try {
         int index = Task.WaitAny(tasks);
         Console.WriteLine("Task #{0} completed first.\n", tasks[index].Id);
         Console.WriteLine("Status of all tasks:");
         foreach (var t in tasks)
            Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status);
      }
      catch (AggregateException) {
         Console.WriteLine("An exception occurred.");
      }
   }
}
// The example displays output like the following:
//     Task #1 completed first.
//
//     Status of all tasks:
//        Task #3: Running
//        Task #1: RanToCompletion
//        Task #4: Running

您也可以等待的一系列任务的调用以完成所有WaitAll方法。 以下示例创建十个任务、 等待十个要完成，然后显示其状态。

C#复制

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      // Wait for all tasks to complete.
      Task[] tasks = new Task[10];
      for (int i = 0; i < 10; i++)
      {
          tasks[i] = Task.Run(() => Thread.Sleep(2000));
      }
      try {
         Task.WaitAll(tasks);
      }
      catch (AggregateException ae) {
         Console.WriteLine("One or more exceptions occurred: ");
         foreach (var ex in ae.Flatten().InnerExceptions)
            Console.WriteLine("   {0}", ex.Message);
      }   

      Console.WriteLine("Status of completed tasks:");
      foreach (var t in tasks)
         Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status);
   }
}
// The example displays the following output:
//     Status of completed tasks:
//        Task #2: RanToCompletion
//        Task #1: RanToCompletion
//        Task #3: RanToCompletion
//        Task #4: RanToCompletion
//        Task #6: RanToCompletion
//        Task #5: RanToCompletion
//        Task #7: RanToCompletion
//        Task #8: RanToCompletion
//        Task #9: RanToCompletion
//        Task #10: RanToCompletion

请注意时等待一个或多个任务完成时，任何正在运行的任务中引发的异常会传播调用的线程上Wait方法，如以下示例所示。 它将启动其中三个正常完成的 12 任务和三个哪些引发的异常。 剩余的六个任务，在开始之前将三个被取消和三个将被取消时执行它们。 在中引发的异常WaitAll方法调用并处理由try / catch块。

C#复制

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      // Create a cancellation token and cancel it.
      var source1 = new CancellationTokenSource();
      var token1 = source1.Token;
      source1.Cancel();
      // Create a cancellation token for later cancellation.
      var source2 = new CancellationTokenSource();
      var token2 = source2.Token;

      // Create a series of tasks that will complete, be cancelled,
      // timeout, or throw an exception.
      Task[] tasks = new Task[12];
      for (int i = 0; i < 12; i++)
      {
          switch (i % 4)
          {
             // Task should run to completion.
             case 0:
                tasks[i] = Task.Run(() => Thread.Sleep(2000));
                break;
             // Task should be set to canceled state.
             case 1:
                tasks[i] = Task.Run( () => Thread.Sleep(2000),
                         token1);
                break;
             case 2:
                // Task should throw an exception.
                tasks[i] = Task.Run( () => { throw new NotSupportedException(); } );
                break;
             case 3:
                // Task should examine cancellation token.
                tasks[i] = Task.Run( () => { Thread.Sleep(2000);
                                             if (token2.IsCancellationRequested)
                                                token2.ThrowIfCancellationRequested();
                                             Thread.Sleep(500); }, token2);
                break;
          }
      }
      Thread.Sleep(250);
      source2.Cancel();

      try {
         Task.WaitAll(tasks);
      }
      catch (AggregateException ae) {
          Console.WriteLine("One or more exceptions occurred:");
          foreach (var ex in ae.InnerExceptions)
             Console.WriteLine("   {0}: {1}", ex.GetType().Name, ex.Message);
       }   

      Console.WriteLine("\nStatus of tasks:");
      foreach (var t in tasks) {
         Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status);
         if (t.Exception != null) {
            foreach (var ex in t.Exception.InnerExceptions)
               Console.WriteLine("      {0}: {1}", ex.GetType().Name,
                                 ex.Message);
         }
      }
   }
}
// The example displays output like the following:
//   One or more exceptions occurred:
//      TaskCanceledException: A task was canceled.
//      NotSupportedException: Specified method is not supported.
//      TaskCanceledException: A task was canceled.
//      TaskCanceledException: A task was canceled.
//      NotSupportedException: Specified method is not supported.
//      TaskCanceledException: A task was canceled.
//      TaskCanceledException: A task was canceled.
//      NotSupportedException: Specified method is not supported.
//      TaskCanceledException: A task was canceled.
//
//   Status of tasks:
//      Task #13: RanToCompletion
//      Task #1: Canceled
//      Task #3: Faulted
//         NotSupportedException: Specified method is not supported.
//      Task #8: Canceled
//      Task #14: RanToCompletion
//      Task #4: Canceled
//      Task #6: Faulted
//         NotSupportedException: Specified method is not supported.
//      Task #7: Canceled
//      Task #15: RanToCompletion
//      Task #9: Canceled
//      Task #11: Faulted
//         NotSupportedException: Specified method is not supported.
//      Task #12: Canceled

有关基于任务的异步操作中的异常处理的详细信息，请参阅异常处理。

任务和区域性

自定位的桌面应用程序.NET Framework 4.6，创建并调用任务的线程的区域性将成为在线程的上下文的一部分。 也就是说，无论执行该任务时的当前区域性，该任务的当前区域性是线程的调用线程的区域性。 对于面向版本之前的.NET Framework 的应用， .NET Framework 4.6，任务的区域性是执行该任务时的线程的区域性。 有关详细信息，请参阅中的"区域性和基于任务的异步操作"部分CultureInfo主题。

备注

应用商店应用程序按照中设置和获取默认区域性的 Windows 运行时。

调试程序开发人员

对于开发人员实现自定义调试器，多个内部和私有成员的任务可能很有用 （这些可能会更改发行版本）。 m_taskId字段用作后备存储Id属性，但是访问此字段直接从调试器可能会通过属性的 getter 方法访问相同的值比效率更高 (s_taskIdCounter计数器是用于检索任务的下一个可用 ID）。 同样，m_stateFlags字段存储的信息还可通过访问任务信息的当前生命周期阶段Status属性。 m_action字段存储对任务的委托的引用和m_stateObject字段存储由开发人员传递给任务的异步状态。 最后，对于分析堆栈帧的调试器InternalWait方法提供一项任务时进入一个等待操作的潜在标记。

构造函数

Task(Action)	使用指定的操作初始化新的 Task。
Task(Action, CancellationToken)	使用指定的操作和 Task 初始化新的 CancellationToken。
Task(Action, CancellationToken, TaskCreationOptions)	使用指定的操作和创建选项初始化新的 Task。
Task(Action, TaskCreationOptions)	使用指定的操作和创建选项初始化新的 Task。
Task(Action<Object>, Object)	使用指定的操作和状态初始化新的 Task。
Task(Action<Object>, Object, CancellationToken)	使用指定的操作、状态和选项初始化新的 Task。
Task(Action<Object>, Object, CancellationToken, TaskCreationOptions)	使用指定的操作、状态和选项初始化新的 Task。
Task(Action<Object>, Object, TaskCreationOptions)	使用指定的操作、状态和选项初始化新的 Task。

属性

AsyncState	获取在创建 Task 时提供的状态对象，如果未提供，则为 null。
CompletedTask	获取一个已成功完成的任务。
CreationOptions	获取用于创建此任务的 TaskCreationOptions。
CurrentId	返回当前正在执行 Task 的 ID。
Exception	获取导致 AggregateException 提前结束的 Task。 如果 Task 成功完成或尚未引发任何异常，这将返回 null。
Factory	提供对用于创建 Task 和 Task<TResult> 的工厂方法的访问。
Id	获取此 Task 实例的 ID。
IsCanceled	获取此 Task 实例是否由于被取消的原因而已完成执行。
IsCompleted	获取此 Task 是否已完成。
IsFaulted	获取 Task 是否由于未经处理异常的原因而完成。
Status	获取此任务的 TaskStatus。

方法

ConfigureAwait(Boolean)	配置用于等待此 Task的 awaiter。
ContinueWith(Action<Task,Object>, Object)	创建一个在目标 Task 完成时接收调用方提供的状态信息并执行的延续任务。
ContinueWith(Action<Task,Object>, Object, CancellationToken)	创建一个在目标 Task 完成时接收调用方提供的状态信息和取消标记，并以异步方式执行的延续任务。
ContinueWith(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	创建一个在目标 Task 完成时接收调用方提供的状态信息和取消标记并执行的延续任务。 延续任务根据一组指定的条件执行，并使用指定的计划程序。
ContinueWith(Action<Task,Object>, Object, TaskContinuationOptions)	创建一个在目标 Task 完成时接收调用方提供的状态信息并执行的延续任务。 延续任务根据一组指定的条件执行。
ContinueWith(Action<Task,Object>, Object, TaskScheduler)	创建一个在目标 Task 完成时接收调用方提供的状态信息并以异步方式执行的延续任务。 延续任务使用指定计划程序。
ContinueWith(Action<Task>)	创建一个在目标 Task 完成时异步执行的延续任务。
ContinueWith(Action<Task>, CancellationToken)	创建一个在目标 Task 完成时可接收取消标记并以异步方式执行的延续任务。
ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler)	创建一个在目标任务完成时按照指定的 TaskContinuationOptions 执行的延续任务。 延续任务会收到一个取消标记，并使用指定计划程序。
ContinueWith(Action<Task>, TaskContinuationOptions)	创建一个在目标任务完成时按照指定的 TaskContinuationOptions 执行的延续任务。
ContinueWith(Action<Task>, TaskScheduler)	创建一个在目标 Task 完成时异步执行的延续任务。 延续任务使用指定计划程序。
ContinueWith<TResult>(Func<Task,Object,TResult>, Object)	创建一个在目标 Task 完成并返回一个值时接收调用方提供的状态信息并以异步方式执行的延续任务。
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken)	创建一个在目标 Task 完成时异步执行并返回一个值的延续任务。 延续任务接收调用方提供的状态信息和取消标记。
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	创建一个在目标 Task 完成并返回一个值时根据指定的任务延续选项执行的延续任务。 延续任务接收调用方提供的状态信息和取消标记，并使用指定计划程序。
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskContinuationOptions)	创建一个在目标 Task 完成时根据指定的任务延续选项执行的延续任务。 延续任务接收调用方提供的状态信息。
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskScheduler)	创建一个在目标 Task 完成时异步执行的延续任务。 延续任务接收调用方提供的状态信息，并使用指定计划程序。
ContinueWith<TResult>(Func<Task,TResult>)	创建一个在目标 Task<TResult> 完成时异步执行并返回一个值的延续任务。
ContinueWith<TResult>(Func<Task,TResult>, CancellationToken)	创建一个在目标 Task 完成时异步执行并返回一个值的延续任务。 延续任务收到取消标记。
ContinueWith<TResult>(Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	创建一个按照指定延续任务选项执行并返回一个值的延续任务。 延续任务被传入一个取消标记，并使用指定计划程序。
ContinueWith<TResult>(Func<Task,TResult>, TaskContinuationOptions)	创建一个按照指定延续任务选项执行并返回一个值的延续任务。
ContinueWith<TResult>(Func<Task,TResult>, TaskScheduler)	创建一个在目标 Task 完成时异步执行并返回一个值的延续任务。 延续任务使用指定计划程序。
Delay(Int32)	创建一个在指定的毫秒数后完成的任务。
Delay(Int32, CancellationToken)	创建一个在指定的毫秒数后完成的可取消任务。
Delay(TimeSpan)	创建一个在指定的时间间隔后完成的任务。
Delay(TimeSpan, CancellationToken)	创建一个在指定的时间间隔后完成的可取消任务。
Dispose()	释放 Task 类的当前实例所使用的所有资源。
Dispose(Boolean)	释放 Task，同时释放其所有非托管资源。
Equals(Object)	确定指定的对象是否等于当前对象。 (Inherited from Object)
FromCanceled(CancellationToken)	创建 Task，它因指定的取消标记进行的取消操作而完成。
FromCanceled<TResult>(CancellationToken)	创建 Task<TResult>，它因指定的取消标记进行的取消操作而完成。
FromException(Exception)	创建 Task，它是以指定的异常来完成的。
FromException<TResult>(Exception)	创建 Task<TResult>，它是以指定的异常来完成的。
FromResult<TResult>(TResult)	创建指定结果的、成功完成的 Task<TResult>。
GetAwaiter()	获取用于等待此 Task 的 awaiter。
GetHashCode()	作为默认哈希函数。 (Inherited from Object)
GetType()	获取当前实例的 Type。 (Inherited from Object)
MemberwiseClone()	创建当前 Object 的浅表副本。 (Inherited from Object)
Run(Action)	将在线程池上运行的指定工作排队，并返回代表该工作的 Task 对象。
Run(Action, CancellationToken)	将在线程池上运行的指定工作排队，并返回代表该工作的 Task 对象。 借助取消标记，可取消工作。
Run(Func<Task>)	将在线程池上运行的指定工作排队，并返回 function 所返回的任务的代理项。
Run(Func<Task>, CancellationToken)	将在线程池上运行的指定工作排队，并返回 function 所返回的任务的代理项。
Run<TResult>(Func<Task<TResult>>)	将指定的工作排成队列在线程池上运行，并返回由 function 返回的 Task(TResult) 的代理。
Run<TResult>(Func<Task<TResult>>, CancellationToken)	将指定的工作排成队列在线程池上运行，并返回由 function 返回的 Task(TResult) 的代理。
Run<TResult>(Func<TResult>)	将在线程池上运行的指定工作排队，并返回代表该工作的 Task<TResult> 对象。
Run<TResult>(Func<TResult>, CancellationToken)	将在线程池上运行的指定工作排队，并返回代表该工作的 Task(TResult) 对象。 借助取消标记，可取消工作。
RunSynchronously()	对当前的 Task 同步运行 TaskScheduler。
RunSynchronously(TaskScheduler)	对提供的 Task 同步运行 TaskScheduler。
Start()	启动 Task，并将它安排到当前的 TaskScheduler 中执行。
Start(TaskScheduler)	启动 Task，并将它安排到指定的 TaskScheduler 中执行。
ToString()	返回表示当前对象的字符串。 (Inherited from Object)
Wait()	等待 Task 完成执行过程。
Wait(CancellationToken)	等待 Task 完成执行过程。 如果在任务完成之前取消标记已取消，等待将终止。
Wait(Int32)	等待 Task 在指定的毫秒数内完成执行。
Wait(Int32, CancellationToken)	等待 Task 完成执行过程。 如果在任务完成之前超时间隔结束或取消标记已取消，等待将终止。
Wait(TimeSpan)	等待 Task 在指定的时间间隔内完成执行。
WaitAll(Task[])	等待提供的所有 Task 对象完成执行过程。
WaitAll(Task[], CancellationToken)	等待提供的所有 Task 对象完成执行过程（除非取消等待）。
WaitAll(Task[], Int32)	等待所有提供的 Task 在指定的毫秒数内完成执行。
WaitAll(Task[], Int32, CancellationToken)	等待提供的所有 Task 对象在指定的毫秒数内完成执行，或等到取消等待。
WaitAll(Task[], TimeSpan)	等待所有提供的可取消 Task 对象在指定的时间间隔内完成执行。
WaitAny(Task[])	等待提供的任一 Task 对象完成执行过程。
WaitAny(Task[], CancellationToken)	等待提供的任何 Task 对象完成执行过程（除非取消等待）。
WaitAny(Task[], Int32)	等待任何提供的 Task 对象在指定的毫秒数内完成执行。
WaitAny(Task[], Int32, CancellationToken)	等待提供的任何 Task 对象在指定的毫秒数内完成执行，或等到取消标记取消。
WaitAny(Task[], TimeSpan)	等待任何提供的 Task 对象在指定的时间间隔内完成执行。
WhenAll(IEnumerable<Task>)	创建一个任务，该任务将在可枚举集合中的所有 Task 对象都完成时完成。
WhenAll(Task[])	创建一个任务，该任务将在数组中的所有 Task 对象都完成时完成。
WhenAll<TResult>(IEnumerable<Task<TResult>>)	创建一个任务，该任务将在可枚举集合中的所有 Task<TResult> 对象都完成时完成。
WhenAll<TResult>(Task<TResult>[])	创建一个任务，该任务将在数组中的所有 Task<TResult> 对象都完成时完成。
WhenAny(IEnumerable<Task>)	任何提供的任务已完成时，创建将完成的任务。
WhenAny(Task[])	任何提供的任务已完成时，创建将完成的任务。
WhenAny<TResult>(IEnumerable<Task<TResult>>)	任何提供的任务已完成时，创建将完成的任务。
WhenAny<TResult>(Task<TResult>[])	任何提供的任务已完成时，创建将完成的任务。
Yield()	创建异步产生当前上下文的等待任务。

显式界面实现

IAsyncResult.AsyncWaitHandle	获取可用于等待任务完成的 WaitHandle。
IAsyncResult.CompletedSynchronously	获取操作是否已同步完成的指示。

适用于

.NET Core

2.1 2.0 1.1 1.0

.NET Framework

4.7.2 4.7.1 4.7 4.6.2 4.6.1 4.6 4.5.2 4.5.1 4.5 4.0

.NET Standard

2.0 1.6 1.4 1.3 1.2 1.1 1.0

Xamarin.Android

7.1

Xamarin.iOS

10.8

Xamarin.Mac

3.0

线程安全性

所有成员Task，除Dispose()、 是线程安全的可从多个线程同时使用。

另请参阅

• Task<TResult>
• 任务并行库 (TPL) Task Parallel Library (TPL)
• 基于任务的异步编程 Task-based Asynchronous Programming
• 使用.NET Framework 进行并行编程示例 Samples for Parallel Programming with the .NET Framework