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
派生
实现

注解

有关此 API 的详细信息,请参阅 Task的 补充 API 备注。

构造函数

Task(Action)

使用指定的操作初始化新的 Task

Task(Action, CancellationToken)

使用指定的操作和 CancellationToken初始化新的 Task

Task(Action, CancellationToken, TaskCreationOptions)

使用指定的操作和创建选项初始化新的 Task

Task(Action, TaskCreationOptions)

使用指定的操作和创建选项初始化新的 Task

Task(Action<Object>, Object)

使用指定的操作和状态初始化新的 Task

Task(Action<Object>, Object, CancellationToken)

使用指定的操作、状态和 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

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

Factory

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

Id

获取此 Task 实例的 ID。

IsCanceled

获取此 Task 实例是否已完成执行,因为已取消。

IsCompleted

获取一个值,该值指示任务是否已完成。

IsCompletedSuccessfully

获取任务是否运行到完成。

IsFaulted

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

Status

获取此任务的 TaskStatus

方法

ConfigureAwait(Boolean)

配置用于等待此 Task的 awaiter。

ConfigureAwait(ConfigureAwaitOptions)

配置用于等待此 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)

创建在指定时间间隔后完成的可取消任务。

Delay(TimeSpan, TimeProvider)

创建在指定时间间隔后完成的任务。

Delay(TimeSpan, TimeProvider, CancellationToken)

创建在指定时间间隔后完成的可取消任务。

Dispose()

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

Dispose(Boolean)

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

Equals(Object)

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

(继承自 Object)
FromCanceled(CancellationToken)

创建一个 Task,该 Task 由于使用指定的取消令牌取消而完成。

FromCanceled<TResult>(CancellationToken)

创建一个 Task<TResult>,该 Task<TResult> 由于使用指定的取消令牌取消而完成。

FromException(Exception)

创建已完成指定异常的 Task

FromException<TResult>(Exception)

创建使用指定异常完成的 Task<TResult>

FromResult<TResult>(TResult)

创建使用指定结果成功完成的 Task<TResult>

GetAwaiter()

获取用于等待此 Task的等待程序。

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()

在当前 TaskScheduler同步运行 Task

RunSynchronously(TaskScheduler)

在提供的 TaskScheduler 上同步运行 Task

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(IEnumerable<Task>, CancellationToken)

等待提供的所有 Task 对象完成执行,除非取消等待。

WaitAll(ReadOnlySpan<Task>)

等待提供的所有 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 请求取消时完成。

WaitAsync(TimeSpan, TimeProvider)

获取一个 Task,该 Task 完成或指定的超时到期时完成。

WaitAsync(TimeSpan, TimeProvider, CancellationToken)

获取一个 Task,该 Task 完成、指定的超时到期或指定的 CancellationToken 请求取消时完成。

WhenAll(IEnumerable<Task>)

创建一个任务,该任务将在可枚举集合中的所有 Task 对象完成时完成。

WhenAll(ReadOnlySpan<Task>)

创建一个任务,该任务将在所有提供的任务完成时完成。

WhenAll(Task[])

创建一个任务,该任务将在数组中的所有 Task 对象完成时完成。

WhenAll<TResult>(IEnumerable<Task<TResult>>)

创建一个任务,该任务将在可枚举集合中的所有 Task<TResult> 对象完成时完成。

WhenAll<TResult>(ReadOnlySpan<Task<TResult>>)

创建一个任务,该任务将在所有提供的任务完成时完成。

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

创建一个任务,该任务将在数组中的所有 Task<TResult> 对象完成时完成。

WhenAny(IEnumerable<Task>)

创建一个任务,该任务将在任何提供的任务完成时完成。

WhenAny(ReadOnlySpan<Task>)

创建一个任务,该任务将在任何提供的任务完成时完成。

WhenAny(Task, Task)

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

WhenAny(Task[])

创建一个任务,该任务将在任何提供的任务完成时完成。

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

创建一个任务,该任务将在任何提供的任务完成时完成。

WhenAny<TResult>(ReadOnlySpan<Task<TResult>>)

创建一个任务,该任务将在任何提供的任务完成时完成。

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

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

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

创建一个任务,该任务将在任何提供的任务完成时完成。

WhenEach(IEnumerable<Task>)

创建一个 IAsyncEnumerable<T>,它将在完成这些任务时产生提供的任务。

WhenEach(ReadOnlySpan<Task>)

创建一个 IAsyncEnumerable<T>,它将在完成这些任务时产生提供的任务。

WhenEach(Task[])

创建一个 IAsyncEnumerable<T>,它将在完成这些任务时产生提供的任务。

WhenEach<TResult>(IEnumerable<Task<TResult>>)

创建一个 IAsyncEnumerable<T>,它将在完成这些任务时产生提供的任务。

WhenEach<TResult>(ReadOnlySpan<Task<TResult>>)

创建一个 IAsyncEnumerable<T>,它将在完成这些任务时产生提供的任务。

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

创建一个 IAsyncEnumerable<T>,它将在完成这些任务时产生提供的任务。

Yield()

创建一个可等待的任务,该任务在等待时异步生成回当前上下文。

显式接口实现

IAsyncResult.AsyncWaitHandle

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

IAsyncResult.CompletedSynchronously

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

扩展方法

WaitAsync(Task, TimeSpan, TimeProvider, CancellationToken)

获取一个 Task,该 Task 完成、指定的超时到期或指定的 CancellationToken 请求取消时完成。

DispatcherOperationWait(Task)

无限期等待基础 DispatcherOperation 完成。

DispatcherOperationWait(Task, TimeSpan)

等待基础 DispatcherOperation 完成指定的时间量。

IsDispatcherOperationTask(Task)

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

AsAsyncAction(Task)

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

适用于

线程安全性

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

另请参阅