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