| 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() | 创建一个可等待的任务,该任务在等待时异步生成回当前上下文。 |