Task<TResult> 类

定义

表示一个可以返回值的异步操作。

generic <typename TResult>
public ref class Task : System::Threading::Tasks::Task
public class Task<TResult> : System.Threading.Tasks.Task
type Task<'Result> = class
    inherit Task
Public Class Task(Of TResult)
Inherits Task

类型参数

TResult

Task<TResult> 生成的结果的类型。

继承
Task<TResult>

注解

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

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

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      var t = Task<int>.Run( () => {
                                      // Just loop.
                                      int max = 1000000;
                                      int ctr = 0;
                                      for (ctr = 0; ctr <= max; ctr++) {
                                         if (ctr == max / 2 && DateTime.Now.Hour <= 12) {
                                            ctr++;
                                            break;
                                         }
                                      }
                                      return ctr;
                                    } );
      Console.WriteLine("Finished {0:N0} iterations.", t.Result);
   }
}
// The example displays output like the following:
//        Finished 1,000,001 loop iterations.
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim t As Task(Of Integer) = Task.Run(Function()
                                  Dim max As Integer = 1000000
                                  Dim ctr As Integer
                                  For ctr = 0 to max
                                     If ctr = max \ 2 And Date.Now.Hour <= 12 Then
                                        ctr += 1
                                        Exit For
                                     End If
                                  Next
                                  Return ctr
                               End Function)
      Console.WriteLine("Finished {0:N0} iterations.", t.Result)
   End Sub
End Module
' The example displays the following output:
'       Finished 1,000,001 loop iterations

在 .NET Framework 4 中启动任务的一种替代方法是调用静态 TaskFactory.StartNewTaskFactory<TResult>.StartNew 方法。 该 Task.Factory 属性返回对象 TaskFactory ,属性 Task<TResult>.Factory 返回对象 TaskFactory<TResult> 。 使用其 StartNew 方法的重载可以传递参数、定义任务创建选项并指定任务计划程序。 以下示例使用 TaskFactory<TResult>.StartNew(Func<TResult>) 该方法启动任务。 它在功能上等效于上一示例中的代码。

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      var t = Task<int>.Factory.StartNew( () => {
                                      // Just loop.
                                      int max = 1000000;
                                      int ctr = 0;
                                      for (ctr = 0; ctr <= max; ctr++) {
                                         if (ctr == max / 2 && DateTime.Now.Hour <= 12) {
                                            ctr++;
                                            break;
                                         }
                                      }
                                      return ctr;
                               } );
      Console.WriteLine("Finished {0:N0} iterations.", t.Result);
   }
}
// The example displays the following output:
//        Finished 1000001 loop iterations
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim t = Task(Of Integer).Factory.StartNew(Function()
                                  Dim max As Integer = 1000000
                                  Dim ctr As Integer
                                  For ctr = 0 to max
                                     If ctr = max \ 2 And Date.Now.Hour <= 12 Then
                                       ctr += 1
                                       Exit For
                                     End If
                                  Next
                                  Return ctr
                               End Function)
      Console.WriteLine("Finished {0:N0} iterations.", t.Result)
   End Sub
End Module
' The example displays output like the following:
'       Finished 1,000,001 iterations

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

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

从面向 .NET Framework 4.6 的桌面应用开始,创建和调用任务的线程区域性将成为线程上下文的一部分。 也就是说,无论任务所执行线程的当前区域性如何,任务的当前区域性都是调用线程的区域性。 对于面向 .NET Framework 4.6 之前的 .NET Framework 版本的应用,任务区域性是任务执行线程的区域性。 有关详细信息,请参阅本主题中的 CultureInfo “区域性和基于任务的异步操作”部分。 请注意,应用商店应用遵循设置中的Windows 运行时并获取默认区域性。

对于不返回值的操作,请使用 Task 类。 从 C# 7.0 开始,对于作为值类型而不是引用类型的轻型任务,请使用 System.Threading.Tasks.ValueTask<TResult> 结构。

构造函数

Task<TResult>(Func<Object,TResult>, Object)

使用指定的函数和状态初始化新的 Task<TResult>

Task<TResult>(Func<Object,TResult>, Object, CancellationToken)

使用指定的操作、状态和选项初始化新的 Task<TResult>

Task<TResult>(Func<Object,TResult>, Object, CancellationToken, TaskCreationOptions)

使用指定的操作、状态和选项初始化新的 Task<TResult>

Task<TResult>(Func<Object,TResult>, Object, TaskCreationOptions)

使用指定的操作、状态和选项初始化新的 Task<TResult>

Task<TResult>(Func<TResult>)

使用指定的函数初始化新的 Task<TResult>

Task<TResult>(Func<TResult>, CancellationToken)

使用指定的函数初始化新的 Task<TResult>

Task<TResult>(Func<TResult>, CancellationToken, TaskCreationOptions)

使用指定的函数和创建选项初始化新的 Task<TResult>

Task<TResult>(Func<TResult>, TaskCreationOptions)

使用指定的函数和创建选项初始化新的 Task<TResult>

属性

AsyncState

获取在创建 Task 时提供的状态对象,如果未提供,则为 null。

(继承自 Task)
CreationOptions

获取用于创建此任务的 TaskCreationOptions

(继承自 Task)
Exception

获取导致 AggregateException 提前结束的 Task。 如果 Task 成功完成或尚未引发任何异常,这将返回 null

(继承自 Task)
Factory

获取用于创建和配置 Task<TResult> 实例的工厂方法。

Id

获取此 Task 实例的 ID。

(继承自 Task)
IsCanceled

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

(继承自 Task)
IsCompleted

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

(继承自 Task)
IsCompletedSuccessfully

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

(继承自 Task)
IsFaulted

获取 Task 是否由于未经处理异常的原因而完成。

(继承自 Task)
Result

获取此 Task<TResult> 的结果值。

Status

获取此任务的 TaskStatus

(继承自 Task)

方法

ConfigureAwait(Boolean)

配置用于等待此 Task<TResult>的 awaiter。

ConfigureAwait(Boolean)

配置用于等待此 Task的 awaiter。

(继承自 Task)
ContinueWith(Action<Task,Object>, Object)

创建一个在目标 Task 完成时接收调用方提供的状态信息并执行的延续任务。

(继承自 Task)
ContinueWith(Action<Task,Object>, Object, CancellationToken)

创建一个在目标 Task 完成时接收调用方提供的状态信息和取消标记,并以异步方式执行的延续任务。

(继承自 Task)
ContinueWith(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)

创建一个在目标 Task 完成时接收调用方提供的状态信息和取消标记并执行的延续任务。 延续任务根据一组指定的条件执行,并使用指定的计划程序。

(继承自 Task)
ContinueWith(Action<Task,Object>, Object, TaskContinuationOptions)

创建一个在目标 Task 完成时接收调用方提供的状态信息并执行的延续任务。 延续任务根据一组指定的条件执行。

(继承自 Task)
ContinueWith(Action<Task,Object>, Object, TaskScheduler)

创建一个在目标 Task 完成时接收调用方提供的状态信息并以异步方式执行的延续任务。 延续任务使用指定计划程序。

(继承自 Task)
ContinueWith(Action<Task<TResult>,Object>, Object)

创建一个传递有状态信息并在目标 Task<TResult> 完成时执行的延续。

ContinueWith(Action<Task<TResult>,Object>, Object, CancellationToken)

创建一个在目标 Task<TResult> 完成时执行的延续任务。

ContinueWith(Action<Task<TResult>,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)

创建一个在目标 Task<TResult> 完成时执行的延续任务。

ContinueWith(Action<Task<TResult>,Object>, Object, TaskContinuationOptions)

创建一个在目标 Task<TResult> 完成时执行的延续任务。

ContinueWith(Action<Task<TResult>,Object>, Object, TaskScheduler)

创建一个在目标 Task<TResult> 完成时执行的延续任务。

ContinueWith(Action<Task<TResult>>)

创建一个在目标任务完成时异步执行的延续任务。

ContinueWith(Action<Task<TResult>>, CancellationToken)

创建一个在目标 Task<TResult> 完成时异步执行的可取消延续任务。

ContinueWith(Action<Task<TResult>>, CancellationToken, TaskContinuationOptions, TaskScheduler)

创建根据 continuationOptions 中指定的条件加以执行的延续任务。

ContinueWith(Action<Task<TResult>>, TaskContinuationOptions)

创建根据 continuationOptions 中指定的条件加以执行的延续任务。

ContinueWith(Action<Task<TResult>>, TaskScheduler)

创建一个在目标 Task<TResult> 完成时异步执行的延续任务。

ContinueWith(Action<Task>)

创建一个在目标 Task 完成时异步执行的延续任务。

(继承自 Task)
ContinueWith(Action<Task>, CancellationToken)

创建一个在目标 Task 完成时可接收取消标记并以异步方式执行的延续任务。

(继承自 Task)
ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler)

创建一个在目标任务完成时按照指定的 TaskContinuationOptions 执行的延续任务。 延续任务会收到一个取消标记,并使用指定的计划程序。

(继承自 Task)
ContinueWith(Action<Task>, TaskContinuationOptions)

创建一个在目标任务完成时按照指定的 TaskContinuationOptions 执行的延续任务。

(继承自 Task)
ContinueWith(Action<Task>, TaskScheduler)

创建一个在目标 Task 完成时异步执行的延续任务。 延续任务使用指定计划程序。

(继承自 Task)
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object)

创建一个在目标 Task<TResult> 完成时执行的延续任务。

ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, CancellationToken)

创建一个在目标 Task<TResult> 完成时执行的延续任务。

ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)

创建一个在目标 Task<TResult> 完成时执行的延续任务。

ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, TaskContinuationOptions)

创建一个在目标 Task<TResult> 完成时执行的延续任务。

ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, TaskScheduler)

创建一个在目标 Task<TResult> 完成时执行的延续任务。

ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>)

创建一个在目标 Task<TResult> 完成时异步执行的延续任务。

ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, CancellationToken)

创建一个在目标 Task<TResult> 完成时异步执行的延续任务。

ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)

创建根据 continuationOptions 中指定的条件加以执行的延续任务。

ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, TaskContinuationOptions)

创建根据 continuationOptions 中指定的条件加以执行的延续任务。

ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, TaskScheduler)

创建一个在目标 Task<TResult> 完成时异步执行的延续任务。

ContinueWith<TResult>(Func<Task,Object,TResult>, Object)

创建一个在目标 Task 完成并返回一个值时接收调用方提供的状态信息并以异步方式执行的延续任务。

(继承自 Task)
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken)

创建一个在目标 Task 完成时异步执行并返回一个值的延续任务。 延续任务接收调用方提供的状态信息和取消标记。

(继承自 Task)
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)

创建一个在目标 Task 完成并返回一个值时根据指定的任务延续选项执行的延续任务。 延续任务接收调用方提供的状态信息和取消标记,并使用指定的计划程序。

(继承自 Task)
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskContinuationOptions)

创建一个在目标 Task 完成时根据指定的任务延续选项执行的延续任务。 延续任务接收调用方提供的状态信息。

(继承自 Task)
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskScheduler)

创建一个在目标 Task 完成时异步执行的延续任务。 延续任务接收调用方提供的状态信息,并使用指定的计划程序。

(继承自 Task)
ContinueWith<TResult>(Func<Task,TResult>)

创建一个在目标 Task<TResult> 完成时异步执行并返回一个值的延续任务。

(继承自 Task)
ContinueWith<TResult>(Func<Task,TResult>, CancellationToken)

创建一个在目标 Task 完成时异步执行并返回一个值的延续任务。 延续任务收到取消标记。

(继承自 Task)
ContinueWith<TResult>(Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)

创建一个按照指定延续任务选项执行并返回一个值的延续任务。 延续任务被传入一个取消标记,并使用指定的计划程序。

(继承自 Task)
ContinueWith<TResult>(Func<Task,TResult>, TaskContinuationOptions)

创建一个按照指定延续任务选项执行并返回一个值的延续任务。

(继承自 Task)
ContinueWith<TResult>(Func<Task,TResult>, TaskScheduler)

创建一个在目标 Task 完成时异步执行并返回一个值的延续任务。 延续任务使用指定计划程序。

(继承自 Task)
Dispose()

释放 Task 类的当前实例所使用的所有资源。

(继承自 Task)
Dispose(Boolean)

释放 Task,同时释放其所有非托管资源。

(继承自 Task)
Equals(Object)

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

(继承自 Object)
GetAwaiter()

获取用于等待此 Task<TResult> 的 awaiter。

GetAwaiter()

获取用于等待此 Task 的 awaiter。

(继承自 Task)
GetHashCode()

作为默认哈希函数。

(继承自 Object)
GetType()

获取当前实例的 Type

(继承自 Object)
MemberwiseClone()

创建当前 Object 的浅表副本。

(继承自 Object)
RunSynchronously()

对当前的 Task 同步运行 TaskScheduler

(继承自 Task)
RunSynchronously(TaskScheduler)

对提供的 Task 同步运行 TaskScheduler

(继承自 Task)
Start()

启动 Task,并将它安排到当前的 TaskScheduler 中执行。

(继承自 Task)
Start(TaskScheduler)

启动 Task,并将它安排到指定的 TaskScheduler 中执行。

(继承自 Task)
ToString()

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

(继承自 Object)
Wait()

等待 Task 完成执行过程。

(继承自 Task)
Wait(CancellationToken)

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

(继承自 Task)
Wait(Int32)

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

(继承自 Task)
Wait(Int32, CancellationToken)

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

(继承自 Task)
Wait(TimeSpan)

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

(继承自 Task)
Wait(TimeSpan, CancellationToken)

等待 Task 完成执行过程。

(继承自 Task)
WaitAsync(CancellationToken)

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

WaitAsync(CancellationToken)

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

(继承自 Task)
WaitAsync(TimeSpan)

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

WaitAsync(TimeSpan)

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

(继承自 Task)
WaitAsync(TimeSpan, CancellationToken)

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

WaitAsync(TimeSpan, CancellationToken)

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

(继承自 Task)

显式接口实现

IAsyncResult.AsyncWaitHandle

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

(继承自 Task)
IAsyncResult.CompletedSynchronously

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

(继承自 Task)

扩展方法

DispatcherOperationWait(Task)

无限期等待完成基础 DispatcherOperation

DispatcherOperationWait(Task, TimeSpan)

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

IsDispatcherOperationTask(Task)

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

AsAsyncAction(Task)

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

AsAsyncOperation<TResult>(Task<TResult>)

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

适用于

线程安全性

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

另请参阅