Task 类

定义

表示一个异步操作。

public ref class Task : IAsyncResult
public ref class Task : IAsyncResult, IDisposable
public class Task : IAsyncResult
public class Task : IAsyncResult, IDisposable
type Task = class
    interface IAsyncResult
type Task = class
    interface IAsyncResult
    interface IDisposable
Public Class Task
Implements IAsyncResult
Public Class Task
Implements IAsyncResult, IDisposable
继承
Task
派生
实现

注解

Task 表示一个不返回值且通常异步执行的单个操作。 Task对象是首先在 .NET Framework 4 中引入的基于任务的异步模式的中心组件之一。 由于对象执行Task的工作通常以异步方式在线程池线程上执行,而不是在主应用程序线程上同步执行,因此可以使用Status属性以及属性IsCanceledIsCompletedIsFaulted属性来确定任务的状态。 通常,lambda 表达式用于指定任务要执行的工作。

对于返回值的操作,请使用 Task<TResult> 该类。

本部分内容:

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

任务实例化

以下示例创建和执行四个任务。 Three tasks execute an Action<T> delegate named action, which accepts an argument of type Object. 第四个任务执行 lambda 表达式, Action (调用任务创建方法时内联定义的委托) 。 每个任务都以不同的方式实例化并运行:

  • 任务t1通过调用 Task 类构造函数进行实例化,但仅在任务t2启动后才调用其Start()方法。

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

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

  • 任务 t4 通过调用 RunSynchronously() 方法在主线程上同步执行。

由于任务 t4 同步执行,因此它会在主应用程序线程上执行。 其余任务通常以异步方式在一个或多个线程池线程上执行。

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
Imports System.Threading
Imports System.Threading.Tasks

Module Example
    Public Sub Main()
        Dim action As Action(Of Object) = 
              Sub(obj As Object)
                 Console.WriteLine("Task={0}, obj={1}, Thread={2}", 
                 Task.CurrentId, obj,
                 Thread.CurrentThread.ManagedThreadId)
              End Sub

        ' Construct an unstarted task
        Dim t1 As New Task(action, "alpha")

        ' Construct a started task
        Dim t2 As Task = 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.
        Dim taskData As String = "delta"
        Dim t3 As Task = Task.Run(Sub()
                                     Console.WriteLine("Task={0}, obj={1}, Thread={2}",
                                     Task.CurrentId, taskData,
                                     Thread.CurrentThread.ManagedThreadId)
                                  End Sub)
        ' Wait for the task to finish.
        t3.Wait()
        
        ' Construct an unstarted task
        Dim t4 As 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()
    End Sub
End Module
' 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=3
'       Task=3, obj=delta, Thread=3
'       Task=4, obj=gamma, Thread=1

创建和执行任务

Task 可以通过多种方式创建实例。 从 .NET Framework 4.5 开始,最常见的方法是调用静态Run方法。 此方法 Run 提供了一种使用默认值启动任务的简单方法,而无需其他参数。 以下示例使用 Run(Action) 该方法启动循环的任务,然后显示循环迭代数:

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
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim t As Task = Task.Run(Sub()
                                  ' Just loop.
                                  Dim ctr As Integer = 0
                                  For ctr = 0 to 1000000
                                  Next
                                  Console.WriteLine("Finished {0} loop iterations",
                                                    ctr)
                               End Sub)
      t.Wait()
   End Sub
End Module
' The example displays the following output:
'       Finished 1000001 loop iterations

一种替代方法,也是在 .NET Framework 4 中启动任务的最常见方法是静态TaskFactory.StartNew方法。 该 Task.Factory 属性返回对象 TaskFactory 。 使用此方法的 TaskFactory.StartNew 重载可以指定参数以传递给任务创建选项和任务计划程序。 以下示例使用 TaskFactory.StartNew 该方法启动任务。 它在功能上等效于上一示例中的代码。

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
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim t As Task = Task.Factory.StartNew(Sub()
                                  ' Just loop.
                                  Dim ctr As Integer = 0
                                  For ctr = 0 to 1000000
                                  Next
                                  Console.WriteLine("Finished {0} loop iterations",
                                                    ctr)
                               End Sub)
      t.Wait()
   End Sub
End Module
' The example displays the following output:
'       Finished 1000001 loop iterations

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

分离任务创建和执行

Task 类还提供用于初始化任务但不计划任务的构造函数执行。 出于性能原因, Task.RunTaskFactory.StartNew 方法是创建和计划计算任务的首选机制,但对于必须分隔创建和计划的方案,可以使用构造函数,然后调用 Task.Start 该方法在以后计划任务执行。

等待一个或多个任务完成

由于任务通常在线程池线程上异步运行,因此在实例化任务后,创建和启动任务的线程会继续执行。 在某些情况下,当调用线程是主应用程序线程时,应用可能会在任务实际开始执行之前终止。 其他情况下,应用程序的逻辑可能要求调用线程仅在一个或多个任务完成执行时才继续执行。 可以通过调用 Wait 方法等待一个或多个任务完成来同步调用线程的执行及其启动的异步任务。

若要等待单个任务完成,可以调用其 Task.Wait 方法。 对方法的 Wait 调用会阻止调用线程,直到单个类实例完成执行。

以下示例调用无 Wait() 参数方法以无条件等待,直到任务完成。 该任务通过调用 Thread.Sleep 方法休眠两秒来模拟工作。

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
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      ' Wait on a single task with no timeout specified.
      Dim taskA = Task.Run( Sub() Thread.Sleep(2000))
      Console.WriteLine("taskA Status: {0}", taskA.Status)
      Try
        taskA.Wait()
        Console.WriteLine("taskA Status: {0}", taskA.Status)
      Catch e As AggregateException
         Console.WriteLine("Exception in taskA.")
      End Try
   End Sub
End Module
' The example displays output like the following:
'     taskA Status: WaitingToRun
'     taskA Status: RanToCompletion

还可以有条件地等待任务完成。 并且Wait(Int32)Wait(TimeSpan)方法会阻止调用线程,直到任务完成或超时间隔过,以先到第一。 由于以下示例启动一个任务,该任务休眠两秒钟,但定义了一秒的超时值,因此调用线程会阻止,直到超时过期,在任务完成执行之前。

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.
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      ' Wait on a single task with a timeout specified.
      Dim taskA As Task = Task.Run( Sub() Thread.Sleep(2000))
      Try
         taskA.Wait(1000)        ' Wait for 1 second.
         Dim completed As Boolean = taskA.IsCompleted
         Console.WriteLine("Task.Completed: {0}, Status: {1}",
                           completed, taskA.Status)
         If Not completed Then 
            Console.WriteLine("Timed out before task A completed.")
         End If                     
      Catch e As AggregateException
         Console.WriteLine("Exception in taskA.")
      End Try
   End Sub
End Module
' The example displays the following output:
'     Task A completed: False, Status: Running
'     Timed out before task A completed.

还可以通过调用 Wait(CancellationToken)Wait(Int32, CancellationToken) 方法来提供取消令牌。 如果在执行该方法时令牌IsCancellationRequested的属性是true或变为true令牌,则该方法将引发一个 OperationCanceledExceptionWait

在某些情况下,你可能希望等待一系列执行任务中的第一个完成,但不关心它所在的任务。 为此,可以调用方法的 Task.WaitAny 重载之一。 以下示例创建三个任务,每个任务都按随机数生成器确定的间隔睡眠。 该方法 WaitAny(Task[]) 等待第一个任务完成。 然后,该示例显示有关所有三个任务的状态的信息。

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
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim tasks(2) As Task
      Dim rnd As New Random()
      For ctr As Integer = 0 To 2
         tasks(ctr) = Task.Run( Sub()  Thread.Sleep(rnd.Next(500, 3000)))
      Next
      
      Try 
         Dim index As Integer= Task.WaitAny(tasks)
         Console.WriteLine("Task #{0} completed first.", tasks(index).Id)
         Console.WriteLine()
         Console.WriteLine("Status of all tasks:")
         For Each t in tasks
            Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status)
         Next   
      Catch e As AggregateException
         Console.WriteLine("An exception occurred.")
      End Try
   End Sub
End Module
' 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 方法等待所有一系列任务完成。 以下示例创建 10 个任务,等待所有 10 个任务完成,然后显示其状态。

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
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      ' Wait for all tasks to complete.
      Dim tasks(9) As Task
      For i As Integer = 0 To 9
          tasks(i) = Task.Run( Sub() Thread.Sleep(2000) )
      Next
      Try 
         Task.WaitAll(tasks)
      Catch ae As AggregateException
         Console.WriteLine("One or more exceptions occurred: ")
         For Each ex In ae.Flatten().InnerExceptions
            Console.WriteLine("   {0}", ex.Message)
         Next
      End Try   

      Console.WriteLine("Status of completed tasks:")
      For Each t in tasks
         Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status)
      Next   
   End Sub
End Module
' 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 个任务,其中 3 个任务正常完成,其中 3 个任务引发异常。 在其余六个任务中,3 个任务在开始之前被取消,3 个任务在执行时被取消。 异常在方法调用中 WaitAll 引发,并由块 try/catch 处理。

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
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      ' Create a cancellation token and cancel it.
      Dim source1 As New CancellationTokenSource()
      Dim token1 As CancellationToken = source1.Token
      source1.Cancel()
      ' Create a cancellation token for later cancellation.
      Dim source2 As New CancellationTokenSource()
      Dim token2 As CancellationToken = source2.Token
       
      ' Create a series of tasks that will complete, be cancelled, 
      ' timeout, or throw an exception.
      Dim tasks(11) As Task
      For i As Integer = 0 To 11
          Select Case i Mod 4 
             ' Task should run to completion.
             Case 0
                tasks(i) = Task.Run( Sub() Thread.Sleep(2000))
             ' Task should be set to canceled state.
             Case 1   
                tasks(i) = Task.Run( Sub() Thread.Sleep(2000), token1)
             Case 2
                ' Task should throw an exception.
                tasks(i) = Task.Run( Sub() 
                                        Throw New NotSupportedException() 
                                     End Sub)
             Case 3
                ' Task should examine cancellation token.
                tasks(i) = Task.Run( Sub() 
                                        Thread.Sleep(2000) 
                                        If token2.IsCancellationRequested
                                           token2.ThrowIfCancellationRequested()
                                        End If
                                        Thread.Sleep(500) 
                                     End Sub, token2)   
          End Select
      Next
      Thread.Sleep(250)
      source2.Cancel()
       
      Try 
         Task.WaitAll(tasks)
      Catch ae As AggregateException
         Console.WriteLine("One or more exceptions occurred:")
         For Each ex in ae.InnerExceptions
             Console.WriteLine("   {0}: {1}", ex.GetType().Name, ex.Message)
         Next
      End Try   
      Console.WriteLine()
      
      Console.WriteLine("Status of tasks:")
      For Each t in tasks
         Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status)
         If t.Exception IsNot Nothing Then
            For Each ex in t.Exception.InnerExceptions
               Console.WriteLine("      {0}: {1}", ex.GetType().Name,
                                 ex.Message)
            Next
         End If
      Next
   End Sub
End Module
' 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 4.6 之前的.NET Framework版本的应用,任务区域性是任务执行线程的区域性。 有关详细信息,请参阅本主题中的 CultureInfo “区域性和基于任务的异步操作”部分。

备注

Microsoft Store应用遵循设置中的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

提供对用于创建和配置 TaskTask<TResult> 实例的工厂方法的访问。

Id

获取此 Task 实例的 ID。

IsCanceled

获取此 Task 实例是否由于被取消的原因而已完成执行。

IsCompleted

获取一个值,它表示是否已完成任务。

IsCompletedSuccessfully

了解任务是否运行到完成。

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)

确定指定对象是否等于当前对象。

(继承自 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()

作为默认哈希函数。

(继承自 Object)
GetType()

获取当前实例的 Type

(继承自 Object)
MemberwiseClone()

创建当前 Object 的浅表副本。

(继承自 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()

返回表示当前对象的字符串。

(继承自 Object)
Wait()

等待 Task 完成执行过程。

Wait(CancellationToken)

等待 Task 完成执行过程。 如果在任务完成之前取消标记已取消,等待将终止。

Wait(Int32)

等待 Task 在指定的毫秒数内完成执行。

Wait(Int32, CancellationToken)

等待 Task 完成执行过程。 如果在任务完成之前超时间隔结束或取消标记已取消,等待将终止。

Wait(TimeSpan)

等待 Task 在指定的时间间隔内完成执行。

Wait(TimeSpan, CancellationToken)

等待 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 对象在指定的时间间隔内完成执行。

WaitAsync(CancellationToken)

获取一个将在此操作Task完成时完成的或Task指定的CancellationToken取消请求时完成的。

WaitAsync(TimeSpan)

获取一个将在此操作Task完成或指定超时过期时完成的项Task

WaitAsync(TimeSpan, CancellationToken)

获取一个将在完成时Task完成的、Task指定的超时过期或请求指定的CancellationToken取消时完成的。

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, Task)

提供的任一任务完成时,创建将完成的任务。

WhenAny(Task[])

任何提供的任务已完成时,创建将完成的任务。

WhenAny<TResult>(IEnumerable<Task<TResult>>)

任何提供的任务已完成时,创建将完成的任务。

WhenAny<TResult>(Task<TResult>, Task<TResult>)

提供的任一任务完成时,创建将完成的任务。

WhenAny<TResult>(Task<TResult>[])

任何提供的任务已完成时,创建将完成的任务。

Yield()

创建异步产生当前上下文的等待任务。

显式接口实现

IAsyncResult.AsyncWaitHandle

获取可用于等待任务完成的 WaitHandle

IAsyncResult.CompletedSynchronously

获取操作是否已同步完成的指示。

扩展方法

DispatcherOperationWait(Task)

无限期等待完成基础 DispatcherOperation

DispatcherOperationWait(Task, TimeSpan)

等待基础 DispatcherOperation 完成,直到达到指定的所需时间。

IsDispatcherOperationTask(Task)

返回一个值,该值指示此 Task 是否与 DispatcherOperation 相关。

AsAsyncAction(Task)

返回表示已开始任务的 Windows 运行时异步操作。

适用于

线程安全性

Dispose()线程外,所有成员Task都是线程安全的,并且可以同时从多个线程使用。

另请参阅