Task.ContinueWith 方法

定义

创建一个在目标 Task 完成时异步执行的延续任务。Creates a continuation that executes asynchronously when the target Task completes.

重载

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

创建一个在目标 Task 完成时接收调用方提供的状态信息和取消标记并执行的延续任务。Creates a continuation that receives caller-supplied state information and a cancellation token and that executes when the target Task completes. 延续任务根据一组指定的条件执行,并使用指定的计划程序。The continuation executes based on a set of specified conditions and uses a specified scheduler.

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

创建一个在目标任务完成时按照指定的 TaskContinuationOptions 执行的延续任务。Creates a continuation that executes when the target task competes according to the specified TaskContinuationOptions. 延续任务会收到一个取消标记,并使用指定的计划程序。The continuation receives a cancellation token and uses a specified scheduler.

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

创建一个在目标 Task 完成时接收调用方提供的状态信息并以异步方式执行的延续任务。Creates a continuation that receives caller-supplied state information and executes asynchronously when the target Task completes. 延续任务使用指定计划程序。The continuation uses a specified scheduler.

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

创建一个在目标 Task 完成时接收调用方提供的状态信息并执行的延续任务。Creates a continuation that receives caller-supplied state information and executes when the target Task completes. 延续任务根据一组指定的条件执行。The continuation executes based on a set of specified conditions.

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

创建一个在目标 Task 完成时接收调用方提供的状态信息和取消标记,并以异步方式执行的延续任务。Creates a continuation that receives caller-supplied state information and a cancellation token and that executes asynchronously when the target Task completes.

ContinueWith(Action<Task,Object>, Object)

创建一个在目标 Task 完成时接收调用方提供的状态信息并执行的延续任务。Creates a continuation that receives caller-supplied state information and executes when the target Task completes.

ContinueWith(Action<Task>, TaskContinuationOptions)

创建一个在目标任务完成时按照指定的 TaskContinuationOptions 执行的延续任务。Creates a continuation that executes when the target task completes according to the specified TaskContinuationOptions.

ContinueWith(Action<Task>, CancellationToken)

创建一个在目标 Task 完成时可接收取消标记并以异步方式执行的延续任务。Creates a continuation that receives a cancellation token and executes asynchronously when the target Task completes.

ContinueWith(Action<Task>)

创建一个在目标 Task 完成时异步执行的延续任务。Creates a continuation that executes asynchronously when the target Task completes.

ContinueWith(Action<Task>, TaskScheduler)

创建一个在目标 Task 完成时异步执行的延续任务。Creates a continuation that executes asynchronously when the target Task completes. 延续任务使用指定计划程序。The continuation uses a specified scheduler.

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

创建一个在目标 Task 完成时根据指定的任务延续选项执行的延续任务。Creates a continuation that executes based on the specified task continuation options when the target Task completes. 延续任务接收调用方提供的状态信息。The continuation receives caller-supplied state information.

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

创建一个在目标 Task 完成并返回一个值时根据指定的任务延续选项执行的延续任务。Creates a continuation that executes based on the specified task continuation options when the target Task completes and returns a value. 延续任务接收调用方提供的状态信息和取消标记,并使用指定的计划程序。The continuation receives caller-supplied state information and a cancellation token and uses the specified scheduler.

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

创建一个按照指定延续任务选项执行并返回一个值的延续任务。Creates a continuation that executes according to the specified continuation options and returns a value. 延续任务被传入一个取消标记,并使用指定的计划程序。The continuation is passed a cancellation token and uses a specified scheduler.

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

创建一个在目标 Task 完成时异步执行的延续任务。Creates a continuation that executes asynchronously when the target Task completes. 延续任务接收调用方提供的状态信息,并使用指定的计划程序。The continuation receives caller-supplied state information and uses a specified scheduler.

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

创建一个在目标 Task 完成时异步执行并返回一个值的延续任务。Creates a continuation that executes asynchronously when the target Task completes and returns a value. 延续任务接收调用方提供的状态信息和取消标记。The continuation receives caller-supplied state information and a cancellation token.

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

创建一个在目标 Task 完成并返回一个值时接收调用方提供的状态信息并以异步方式执行的延续任务。Creates a continuation that receives caller-supplied state information and executes asynchronously when the target Task completes and returns a value.

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

创建一个按照指定延续任务选项执行并返回一个值的延续任务。Creates a continuation that executes according to the specified continuation options and returns a value.

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

创建一个在目标 Task 完成时异步执行并返回一个值的延续任务。Creates a continuation that executes asynchronously when the target Task completes and returns a value. 延续任务收到取消标记。The continuation receives a cancellation token.

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

创建一个在目标 Task<TResult> 完成时异步执行并返回一个值的延续任务。Creates a continuation that executes asynchronously when the target Task<TResult> completes and returns a value.

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

创建一个在目标 Task 完成时异步执行并返回一个值的延续任务。Creates a continuation that executes asynchronously when the target Task completes and returns a value. 延续任务使用指定计划程序。The continuation uses a specified scheduler.

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

创建一个在目标 Task 完成时接收调用方提供的状态信息和取消标记并执行的延续任务。Creates a continuation that receives caller-supplied state information and a cancellation token and that executes when the target Task completes. 延续任务根据一组指定的条件执行,并使用指定的计划程序。The continuation executes based on a set of specified conditions and uses a specified scheduler.

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^, System::Object ^> ^ continuationAction, System::Object ^ state, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskContinuationOptions continuationOptions, System::Threading::Tasks::TaskScheduler ^ scheduler);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object> continuationAction, object state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);
member this.ContinueWith : Action<System.Threading.Tasks.Task, obj> * obj * System.Threading.CancellationToken * System.Threading.Tasks.TaskContinuationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task

参数

continuationAction
Action<Task,Object>

Task 完成时要运行的操作。An action to run when the Task completes. 运行时,委托将作为一个自变量传递给完成的任务和调用方提供的状态对象。When run, the delegate will be passed the completed task and the caller-supplied state object as arguments.

state
Object

一个表示由该延续操作使用的数据的对象。An object representing data to be used by the continuation action.

cancellationToken
CancellationToken

将指派给新的延续任务的 CancellationTokenThe CancellationToken that will be assigned to the new continuation task.

continuationOptions
TaskContinuationOptions

用于设置计划延续任务的时间以及延续任务的工作方式的选项。Options for when the continuation is scheduled and how it behaves. 这包括条件(如 OnlyOnCanceled)和执行选项(如 ExecuteSynchronously)。This includes criteria, such as OnlyOnCanceled, as well as execution options, such as ExecuteSynchronously.

scheduler
TaskScheduler

要与延续任务关联并用于其执行过程的 TaskSchedulerThe TaskScheduler to associate with the continuation task and to use for its execution.

返回

一个新的延续 TaskA new continuation Task.

异常

scheduler 参数为 nullThe scheduler argument is null.

continuationOptions 参数为 TaskContinuationOptions 指定无效值。The continuationOptions argument specifies an invalid value for TaskContinuationOptions.

已释放提供的 CancellationTokenThe provided CancellationToken has already been disposed.

注解

直到当前任务完成后,才会计划执行返回的 TaskThe returned Task will not be scheduled for execution until the current task has completed. 如果未满足通过 continuationOptions 参数指定的条件,则将取消延续任务,而不是计划。If the criteria specified through the continuationOptions parameter are not met, the continuation task will be canceled instead of scheduled.

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

创建一个在目标任务完成时按照指定的 TaskContinuationOptions 执行的延续任务。Creates a continuation that executes when the target task competes according to the specified TaskContinuationOptions. 延续任务会收到一个取消标记,并使用指定的计划程序。The continuation receives a cancellation token and uses a specified scheduler.

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^> ^ continuationAction, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskContinuationOptions continuationOptions, System::Threading::Tasks::TaskScheduler ^ scheduler);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task> continuationAction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);
member this.ContinueWith : Action<System.Threading.Tasks.Task> * System.Threading.CancellationToken * System.Threading.Tasks.TaskContinuationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task

参数

continuationAction
Action<Task>

根据在 continuationOptions 中指定的条件运行的操作。An action to run according to the specified continuationOptions. 在运行时,委托将作为一个自变量传递给完成的任务。When run, the delegate will be passed the completed task as an argument.

cancellationToken
CancellationToken

将指派给新的延续任务的 CancellationTokenThe CancellationToken that will be assigned to the new continuation task.

continuationOptions
TaskContinuationOptions

用于设置计划延续任务的时间以及延续任务的工作方式的选项。Options for when the continuation is scheduled and how it behaves. 这包括条件(如 OnlyOnCanceled)和执行选项(如 ExecuteSynchronously)。This includes criteria, such as OnlyOnCanceled, as well as execution options, such as ExecuteSynchronously.

scheduler
TaskScheduler

要与延续任务关联并用于其执行过程的 TaskSchedulerThe TaskScheduler to associate with the continuation task and to use for its execution.

返回

一个新的延续 TaskA new continuation Task.

异常

创建了该标记的 CancellationTokenSource 已被释放。The CancellationTokenSource that created the token has already been disposed.

continuationAction 参数为 null。The continuationAction argument is null.

- 或 --or- scheduler 参数为 null。The scheduler argument is null.

continuationOptions 参数为 TaskContinuationOptions 指定无效值。The continuationOptions argument specifies an invalid value for TaskContinuationOptions.

示例

下面是使用 System.threading.tasks.task.continuewith 在后台和用户界面线程上运行工作的示例。The following is an example of using ContinueWith to run work both in the background and on the user interface threads.

  
private void Button1_Click(object sender, EventArgs e)  
{  
   var backgroundScheduler = TaskScheduler.Default;  
   var uiScheduler = TaskScheduler.FromCurrentSynchronizationContext();  
   Task.Factory.StartNew(delegate { DoBackgroundComputation(); },  
                         backgroundScheduler).  
   ContinueWith(delegate { UpdateUI(); }, uiScheduler).  
                ContinueWith(delegate { DoAnotherBackgroundComputation(); },  
                             backgroundScheduler).  
                ContinueWith(delegate { UpdateUIAgain(); }, uiScheduler);  
}  
  
  
Private Sub Button1_Click(ByVal sender As System.Object,   
                          ByVal e As System.EventArgs) Handles Button1.Click  
   Dim backgroundScheduler = TaskScheduler.Default  
   Dim uiScheduler = TaskScheduler.FromCurrentSynchronizationContext()  
  
   Task.Factory.StartNew(Sub()  
                           DoBackgroundComputation()  
                         End Sub, backgroundScheduler).ContinueWith(Sub(t)  
                            UpdateUI()  
                         End Sub, uiScheduler).ContinueWith(Sub(t)  
                            DoAnotherBackgroundComputation()  
                         End Sub, backgroundScheduler).ContinueWith(Sub(t)  
                            UpdateUIAgain()  
                         End Sub, uiScheduler)  
End Sub  
  

注解

直到当前任务完成后,才会计划执行返回的 TaskThe returned Task will not be scheduled for execution until the current task has completed. 如果未满足通过 continuationOptions 参数指定的条件,则将取消延续任务,而不是计划。If the criteria specified through the continuationOptions parameter are not met, the continuation task will be canceled instead of scheduled.

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

创建一个在目标 Task 完成时接收调用方提供的状态信息并以异步方式执行的延续任务。Creates a continuation that receives caller-supplied state information and executes asynchronously when the target Task completes. 延续任务使用指定计划程序。The continuation uses a specified scheduler.

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^, System::Object ^> ^ continuationAction, System::Object ^ state, System::Threading::Tasks::TaskScheduler ^ scheduler);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object> continuationAction, object state, System.Threading.Tasks.TaskScheduler scheduler);
member this.ContinueWith : Action<System.Threading.Tasks.Task, obj> * obj * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task
Public Function ContinueWith (continuationAction As Action(Of Task, Object), state As Object, scheduler As TaskScheduler) As Task

参数

continuationAction
Action<Task,Object>

Task 完成时要运行的操作。An action to run when the Task completes. 运行时,委托将作为一个自变量传递给完成的任务和调用方提供的状态对象。When run, the delegate will be passed the completed task and the caller-supplied state object as arguments.

state
Object

一个表示由该延续操作使用的数据的对象。An object representing data to be used by the continuation action.

scheduler
TaskScheduler

要与延续任务关联并用于其执行过程的 TaskSchedulerThe TaskScheduler to associate with the continuation task and to use for its execution.

返回

一个新的延续 TaskA new continuation Task.

异常

scheduler 参数为 nullThe scheduler argument is null.

注解

在当前任务完成之后,将不会计划执行返回的 Task,无论该任务完成的原因是成功完成,还是由于未经处理的异常而发生故障,或由于被取消而导致错误。The returned Task will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

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

创建一个在目标 Task 完成时接收调用方提供的状态信息并执行的延续任务。Creates a continuation that receives caller-supplied state information and executes when the target Task completes. 延续任务根据一组指定的条件执行。The continuation executes based on a set of specified conditions.

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^, System::Object ^> ^ continuationAction, System::Object ^ state, System::Threading::Tasks::TaskContinuationOptions continuationOptions);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object> continuationAction, object state, System.Threading.Tasks.TaskContinuationOptions continuationOptions);
member this.ContinueWith : Action<System.Threading.Tasks.Task, obj> * obj * System.Threading.Tasks.TaskContinuationOptions -> System.Threading.Tasks.Task
Public Function ContinueWith (continuationAction As Action(Of Task, Object), state As Object, continuationOptions As TaskContinuationOptions) As Task

参数

continuationAction
Action<Task,Object>

Task 完成时要运行的操作。An action to run when the Task completes. 运行时,委托将作为一个自变量传递给完成的任务和调用方提供的状态对象。When run, the delegate will be passed the completed task and the caller-supplied state object as arguments.

state
Object

一个表示由该延续操作使用的数据的对象。An object representing data to be used by the continuation action.

continuationOptions
TaskContinuationOptions

用于设置计划延续任务的时间以及延续任务的工作方式的选项。Options for when the continuation is scheduled and how it behaves. 这包括条件(如 OnlyOnCanceled)和执行选项(如 ExecuteSynchronously)。This includes criteria, such as OnlyOnCanceled, as well as execution options, such as ExecuteSynchronously.

返回

一个新的延续 TaskA new continuation Task.

异常

continuationAction 参数为 nullThe continuationAction argument is null.

continuationOptions 参数为 TaskContinuationOptions 指定无效值。The continuationOptions argument specifies an invalid value for TaskContinuationOptions.

注解

直到当前任务完成后,才会计划执行返回的 TaskThe returned Task will not be scheduled for execution until the current task has completed. 如果未满足通过 continuationOptions 参数指定的继续条件,则将取消延续任务,而不是计划。If the continuation criteria specified through the continuationOptions parameter are not met, the continuation task will be canceled instead of scheduled.

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

创建一个在目标 Task 完成时接收调用方提供的状态信息和取消标记,并以异步方式执行的延续任务。Creates a continuation that receives caller-supplied state information and a cancellation token and that executes asynchronously when the target Task completes.

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^, System::Object ^> ^ continuationAction, System::Object ^ state, System::Threading::CancellationToken cancellationToken);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object> continuationAction, object state, System.Threading.CancellationToken cancellationToken);
member this.ContinueWith : Action<System.Threading.Tasks.Task, obj> * obj * System.Threading.CancellationToken -> System.Threading.Tasks.Task

参数

continuationAction
Action<Task,Object>

Task 完成时要运行的操作。An action to run when the Task completes. 运行时,将传递委托,如完成的任务一样,调用方提供的状态对象(如参数)。When run, the delegate will be passed the completed task and the caller-supplied state object as arguments.

state
Object

一个表示由该延续操作使用的数据的对象。An object representing data to be used by the continuation action.

cancellationToken
CancellationToken

将指派给新的延续任务的 CancellationTokenThe CancellationToken that will be assigned to the new continuation task.

返回

一个新的延续 TaskA new continuation Task.

异常

continuationAction 参数为 nullThe continuationAction argument is null.

已释放提供的 CancellationTokenThe provided CancellationToken has already been disposed.

注解

在当前任务完成之后,将不会计划执行返回的 Task,无论该任务完成的原因是成功完成,还是由于未经处理的异常而发生故障,或由于被取消而导致错误。The returned Task will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

ContinueWith(Action<Task,Object>, Object)

创建一个在目标 Task 完成时接收调用方提供的状态信息并执行的延续任务。Creates a continuation that receives caller-supplied state information and executes when the target Task completes.

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^, System::Object ^> ^ continuationAction, System::Object ^ state);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object> continuationAction, object state);
member this.ContinueWith : Action<System.Threading.Tasks.Task, obj> * obj -> System.Threading.Tasks.Task
Public Function ContinueWith (continuationAction As Action(Of Task, Object), state As Object) As Task

参数

continuationAction
Action<Task,Object>

在任务完成时要运行的操作。An action to run when the task completes. 运行时,委托作为一个自变量传递给完成的任务和调用方提供的状态对象。When run, the delegate is passed the completed task and a caller-supplied state object as arguments.

state
Object

一个表示由该延续操作使用的数据的对象。An object representing data to be used by the continuation action.

返回

一个新的延续任务。A new continuation task.

异常

continuationAction 参数为 nullThe continuationAction argument is null.

注解

在当前任务完成之后,将不会计划执行返回的 Task,无论该任务完成的时间是由于运行到成功、发生了未经处理的异常,还是由于取消操作而导致错误。The returned Task will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting early due to cancellation.

ContinueWith(Action<Task>, TaskContinuationOptions)

创建一个在目标任务完成时按照指定的 TaskContinuationOptions 执行的延续任务。Creates a continuation that executes when the target task completes according to the specified TaskContinuationOptions.

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^> ^ continuationAction, System::Threading::Tasks::TaskContinuationOptions continuationOptions);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task> continuationAction, System.Threading.Tasks.TaskContinuationOptions continuationOptions);
member this.ContinueWith : Action<System.Threading.Tasks.Task> * System.Threading.Tasks.TaskContinuationOptions -> System.Threading.Tasks.Task
Public Function ContinueWith (continuationAction As Action(Of Task), continuationOptions As TaskContinuationOptions) As Task

参数

continuationAction
Action<Task>

根据在 continuationOptions 中指定的条件运行的操作。An action to run according to the specified continuationOptions. 在运行时,委托将作为一个自变量传递给完成的任务。When run, the delegate will be passed the completed task as an argument.

continuationOptions
TaskContinuationOptions

用于设置计划延续任务的时间以及延续任务的工作方式的选项。Options for when the continuation is scheduled and how it behaves. 这包括条件(如 OnlyOnCanceled)和执行选项(如 ExecuteSynchronously)。This includes criteria, such as OnlyOnCanceled, as well as execution options, such as ExecuteSynchronously.

返回

一个新的延续 TaskA new continuation Task.

异常

continuationAction 参数为 null。The continuationAction argument is null.

continuationOptions 参数为 TaskContinuationOptions 指定无效值。The continuationOptions argument specifies an invalid value for TaskContinuationOptions.

示例

下面的示例演示如何使用 TaskContinuationOptions 来指定延续任务在前面的任务完成时应同步运行。The following example demonstrates using TaskContinuationOptions to specify that a continuation task should run synchronously when the antecedent task completes. (如果指定的任务已在调用 ContinueWith 时完成,则同步延续将在调用 ContinueWith 的线程上运行。)(If the specified task has already completed by the time ContinueWith is called, the synchronous continuation will run on the thread calling ContinueWith.)

  
public class TaskCounter  
{  
   private volatile int _count;  
  
   public void Track(Task t)  
   {  
      if (t == null) throw new ArgumentNullException("t");  
      Interlocked.Increment(ref _count);  
      t.ContinueWith(ct => Interlocked.Decrement(ref _count), TaskContinuationOptions.ExecuteSynchronously);  
   }  
  
   public int NumberOfActiveTasks { get { return _count; } }  
}  
  
  
Public Class TaskCounter  
   Private _count as Integer  
  
   Public Sub Track(ByVal t as Task)  
      If t is Nothing Then Throw New ArgumentNullException("t")  
      Interlocked.Increment(_count)  
      t.ContinueWith(Sub(ct)  
                        Interlocked.Decrement(_count)  
                     End Sub,  
                     TaskContinuationOptions.ExecuteSynchronously)  
   End Sub  
  
   Public ReadOnly Property NumberOfActiveTasks As Integer  
      Get  
         Return _count  
      End Get  
   End Property  
End Class  
  

注解

直到当前任务完成后,才会计划执行返回的 TaskThe returned Task will not be scheduled for execution until the current task has completed. 如果未满足通过 continuationOptions 参数指定的继续条件,则将取消延续任务,而不是计划。If the continuation criteria specified through the continuationOptions parameter are not met, the continuation task will be canceled instead of scheduled.

ContinueWith(Action<Task>, CancellationToken)

创建一个在目标 Task 完成时可接收取消标记并以异步方式执行的延续任务。Creates a continuation that receives a cancellation token and executes asynchronously when the target Task completes.

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^> ^ continuationAction, System::Threading::CancellationToken cancellationToken);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task> continuationAction, System.Threading.CancellationToken cancellationToken);
member this.ContinueWith : Action<System.Threading.Tasks.Task> * System.Threading.CancellationToken -> System.Threading.Tasks.Task

参数

continuationAction
Action<Task>

Task 完成时要运行的操作。An action to run when the Task completes. 在运行时,委托将作为一个自变量传递给完成的任务。When run, the delegate will be passed the completed task as an argument.

cancellationToken
CancellationToken

将指派给新的延续任务的 CancellationTokenThe CancellationToken that will be assigned to the new continuation task.

返回

一个新的延续 TaskA new continuation Task.

异常

创建了该标记的 CancellationTokenSource 已被释放。The CancellationTokenSource that created the token has already been disposed.

continuationAction 参数为 null。The continuationAction argument is null.

注解

在当前任务完成之后,将不会计划执行返回的 Task,无论该任务完成的原因是成功完成,还是由于未经处理的异常而发生故障,或由于被取消而导致错误。The returned Task will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

ContinueWith(Action<Task>)

创建一个在目标 Task 完成时异步执行的延续任务。Creates a continuation that executes asynchronously when the target Task completes.

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^> ^ continuationAction);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task> continuationAction);
member this.ContinueWith : Action<System.Threading.Tasks.Task> -> System.Threading.Tasks.Task
Public Function ContinueWith (continuationAction As Action(Of Task)) As Task

参数

continuationAction
Action<Task>

Task 完成时要运行的操作。An action to run when the Task completes. 在运行时,委托将作为一个自变量传递给完成的任务。When run, the delegate will be passed the completed task as an argument.

返回

一个新的延续 TaskA new continuation Task.

异常

continuationAction 参数为 nullThe continuationAction argument is null.

示例

下面的示例定义了一个任务,该任务使用100随机日期和时间值填充数组。The following example defines a task that populates an array with 100 random date and time values. 它使用 ContinueWith(Action<Task>) 方法选择完全填充数组后的最早和最晚日期值。It uses the ContinueWith(Action<Task>) method to select the earliest and the latest date values once the array is fully populated.

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      var firstTask = Task.Factory.StartNew( () => {
                               Random rnd = new Random();
                               DateTime[] dates = new DateTime[100];
                               Byte[] buffer = new Byte[8];
                               int ctr = dates.GetLowerBound(0);
                               while (ctr <= dates.GetUpperBound(0)) {
                                  rnd.NextBytes(buffer);
                                  long ticks = BitConverter.ToInt64(buffer, 0);
                                  if (ticks <= DateTime.MinValue.Ticks | ticks >= DateTime.MaxValue.Ticks)
                                     continue;

                                  dates[ctr] = new DateTime(ticks);
                                  ctr++;
                               }
                               return dates;
                            } ); 
                         
      Task continuationTask = firstTask.ContinueWith( (antecedent) => {
                             DateTime[] dates = antecedent.Result;
                             DateTime earliest = dates[0];
                             DateTime latest = earliest;
                             
                             for (int ctr = dates.GetLowerBound(0) + 1; ctr <= dates.GetUpperBound(0); ctr++) {
                                if (dates[ctr] < earliest) earliest = dates[ctr];
                                if (dates[ctr] > latest) latest = dates[ctr];
                             }
                             Console.WriteLine("Earliest date: {0}", earliest);
                             Console.WriteLine("Latest date: {0}", latest);
                          } );                      
      // Since a console application otherwise terminates, wait for the continuation to complete.
     continuationTask.Wait();
   }
}
// The example displays output like the following:
//       Earliest date: 2/11/0110 12:03:41 PM
//       Latest date: 7/29/9989 2:14:49 PM
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim firstTask = Task.Factory.StartNew( Function()
                               Dim rnd As New Random()
                               Dim dates(99) As Date
                               Dim buffer(7) As Byte
                               Dim ctr As Integer = dates.GetLowerBound(0)
                               Do While ctr <= dates.GetUpperBound(0)
                                  rnd.NextBytes(buffer)
                                  Dim ticks As Long = BitConverter.ToInt64(buffer, 0)
                                  If ticks <= DateTime.MinValue.Ticks Or ticks >= DateTime.MaxValue.Ticks Then Continue Do

                                  dates(ctr) = New Date(ticks)
                                  ctr += 1
                               Loop
                               Return dates
                            End Function )
                         
      Dim continuationTask As Task = firstTask.ContinueWith( Sub(antecedent)
                             Dim dates() As Date = antecedent.Result
                             Dim earliest As Date = dates(0)
                             Dim latest As Date = earliest
                             
                             For ctr As Integer = dates.GetLowerBound(0) + 1 To dates.GetUpperBound(0)
                                If dates(ctr) < earliest Then earliest = dates(ctr)
                                If dates(ctr) > latest Then latest = dates(ctr)
                             Next
                             Console.WriteLine("Earliest date: {0}", earliest)
                             Console.WriteLine("Latest date: {0}", latest)
                          End Sub)                      
      ' Since a console application otherwise terminates, wait for the continuation to complete.
      continuationTask.Wait()
   End Sub
End Module
' The example displays output like the following:
'       Earliest date: 2/11/0110 12:03:41 PM
'       Latest date: 7/29/9989 2:14:49 PM

由于控制台应用程序可能会在延续任务执行前终止,因此,将调用 Wait() 方法,以确保延续任务在示例结束之前已完成执行。Because a console application may terminate before the continuation task executes, the Wait() method is called to ensure that the continuation finishes executing before the example ends.

有关其他示例,请参阅使用延续任务链接任务For an additional example, see Chaining Tasks by Using Continuation Tasks.

注解

在当前任务完成之后,将不会计划执行返回的 Task,无论该任务完成的原因是成功完成,还是由于未经处理的异常而发生故障,或由于被取消而导致错误。The returned Task will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

ContinueWith(Action<Task>, TaskScheduler)

创建一个在目标 Task 完成时异步执行的延续任务。Creates a continuation that executes asynchronously when the target Task completes. 延续任务使用指定计划程序。The continuation uses a specified scheduler.

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^> ^ continuationAction, System::Threading::Tasks::TaskScheduler ^ scheduler);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task> continuationAction, System.Threading.Tasks.TaskScheduler scheduler);
member this.ContinueWith : Action<System.Threading.Tasks.Task> * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task
Public Function ContinueWith (continuationAction As Action(Of Task), scheduler As TaskScheduler) As Task

参数

continuationAction
Action<Task>

Task 完成时要运行的操作。An action to run when the Task completes. 在运行时,委托将作为一个自变量传递给完成的任务。When run, the delegate will be passed the completed task as an argument.

scheduler
TaskScheduler

要与延续任务关联并用于其执行过程的 TaskSchedulerThe TaskScheduler to associate with the continuation task and to use for its execution.

返回

一个新的延续 TaskA new continuation Task.

异常

已释放了 TaskThe Task has been disposed.

continuationAction 参数为 nullThe continuationAction argument is null.

- 或 --or- scheduler 参数为 null。The scheduler argument is null.

注解

在当前任务完成之后,将不会计划执行返回的 Task,无论该任务完成的原因是成功完成,还是由于未经处理的异常而发生故障,或由于被取消而导致错误。The returned Task will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

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

创建一个在目标 Task 完成时根据指定的任务延续选项执行的延续任务。Creates a continuation that executes based on the specified task continuation options when the target Task completes. 延续任务接收调用方提供的状态信息。The continuation receives caller-supplied state information.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, System::Object ^, TResult> ^ continuationFunction, System::Object ^ state, System::Threading::Tasks::TaskContinuationOptions continuationOptions);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object,TResult> continuationFunction, object state, System.Threading.Tasks.TaskContinuationOptions continuationOptions);
member this.ContinueWith : Func<System.Threading.Tasks.Task, obj, 'Result> * obj * System.Threading.Tasks.TaskContinuationOptions -> System.Threading.Tasks.Task<'Result>
Public Function ContinueWith(Of TResult) (continuationFunction As Func(Of Task, Object, TResult), state As Object, continuationOptions As TaskContinuationOptions) As Task(Of TResult)

类型参数

TResult

延续任务生成的结果的类型。The type of the result produced by the continuation.

参数

continuationFunction
Func<Task,Object,TResult>

Task 完成时要运行的函数。A function to run when the Task completes. 运行时,委托将作为一个自变量传递给完成的任务和调用方提供的状态对象。When run, the delegate will be passed the completed task and the caller-supplied state object as arguments.

state
Object

一个表示由该延续功能使用的数据的对象。An object representing data to be used by the continuation function.

continuationOptions
TaskContinuationOptions

用于设置计划延续任务的时间以及延续任务的工作方式的选项。Options for when the continuation is scheduled and how it behaves. 这包括条件(如 OnlyOnCanceled)和执行选项(如 ExecuteSynchronously)。This includes criteria, such as OnlyOnCanceled, as well as execution options, such as ExecuteSynchronously.

返回

一个新的延续 Task<TResult>A new continuation Task<TResult>.

异常

continuationFunction 参数为 nullThe continuationFunction argument is null.

continuationOptions 参数为 TaskContinuationOptions 指定无效值。The continuationOptions argument specifies an invalid value for TaskContinuationOptions.

注解

直到当前任务完成后,才会计划执行返回的 Task<TResult>The returned Task<TResult> will not be scheduled for execution until the current task has completed. 如果未满足通过 continuationOptions 参数指定的继续条件,则将取消延续任务,而不是计划。If the continuation criteria specified through the continuationOptions parameter are not met, the continuation task will be canceled instead of scheduled.

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

创建一个在目标 Task 完成并返回一个值时根据指定的任务延续选项执行的延续任务。Creates a continuation that executes based on the specified task continuation options when the target Task completes and returns a value. 延续任务接收调用方提供的状态信息和取消标记,并使用指定的计划程序。The continuation receives caller-supplied state information and a cancellation token and uses the specified scheduler.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, System::Object ^, TResult> ^ continuationFunction, System::Object ^ state, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskContinuationOptions continuationOptions, System::Threading::Tasks::TaskScheduler ^ scheduler);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object,TResult> continuationFunction, object state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);
member this.ContinueWith : Func<System.Threading.Tasks.Task, obj, 'Result> * obj * System.Threading.CancellationToken * System.Threading.Tasks.TaskContinuationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task<'Result>

类型参数

TResult

延续任务生成的结果的类型。The type of the result produced by the continuation.

参数

continuationFunction
Func<Task,Object,TResult>

Task 完成时要运行的函数。A function to run when the Task completes. 运行时,委托将作为一个自变量传递给完成的任务和调用方提供的状态对象。When run, the delegate will be passed the completed task and the caller-supplied state object as arguments.

state
Object

一个表示由该延续功能使用的数据的对象。An object representing data to be used by the continuation function.

cancellationToken
CancellationToken

将指派给新的延续任务的 CancellationTokenThe CancellationToken that will be assigned to the new continuation task.

continuationOptions
TaskContinuationOptions

用于设置计划延续任务的时间以及延续任务的工作方式的选项。Options for when the continuation is scheduled and how it behaves. 这包括条件(如 OnlyOnCanceled)和执行选项(如 ExecuteSynchronously)。This includes criteria, such as OnlyOnCanceled, as well as execution options, such as ExecuteSynchronously.

scheduler
TaskScheduler

要与延续任务关联并用于其执行过程的 TaskSchedulerThe TaskScheduler to associate with the continuation task and to use for its execution.

返回

一个新的延续 Task<TResult>A new continuation Task<TResult>.

异常

scheduler 参数为 nullThe scheduler argument is null.

continuationOptions 参数为 TaskContinuationOptions 指定无效值。The continuationOptions argument specifies an invalid value for TaskContinuationOptions.

已释放提供的 CancellationTokenThe provided CancellationToken has already been disposed.

注解

直到当前任务完成后,才会计划执行返回的 Task<TResult>The returned Task<TResult> will not be scheduled for execution until the current task has completed. 如果未满足通过 continuationOptions 参数指定的条件,则将取消延续任务,而不是计划。If the criteria specified through the continuationOptions parameter are not met, the continuation task will be canceled instead of scheduled.

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

创建一个按照指定延续任务选项执行并返回一个值的延续任务。Creates a continuation that executes according to the specified continuation options and returns a value. 延续任务被传入一个取消标记,并使用指定的计划程序。The continuation is passed a cancellation token and uses a specified scheduler.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, TResult> ^ continuationFunction, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskContinuationOptions continuationOptions, System::Threading::Tasks::TaskScheduler ^ scheduler);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,TResult> continuationFunction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);
member this.ContinueWith : Func<System.Threading.Tasks.Task, 'Result> * System.Threading.CancellationToken * System.Threading.Tasks.TaskContinuationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task<'Result>

类型参数

TResult

延续任务生成的结果的类型。The type of the result produced by the continuation.

参数

continuationFunction
Func<Task,TResult>

根据指定 continuationOptions. 运行的函数。A function to run according to the specified continuationOptions. 在运行时,委托将作为一个自变量传递给完成的任务。When run, the delegate will be passed the completed task as an argument.

cancellationToken
CancellationToken

将指派给新的延续任务的 CancellationTokenThe CancellationToken that will be assigned to the new continuation task.

continuationOptions
TaskContinuationOptions

用于设置计划延续任务的时间以及延续任务的工作方式的选项。Options for when the continuation is scheduled and how it behaves. 这包括条件(如 OnlyOnCanceled)和执行选项(如 ExecuteSynchronously)。This includes criteria, such as OnlyOnCanceled, as well as execution options, such as ExecuteSynchronously.

scheduler
TaskScheduler

要与延续任务关联并用于其执行过程的 TaskSchedulerThe TaskScheduler to associate with the continuation task and to use for its execution.

返回

一个新的延续 Task<TResult>A new continuation Task<TResult>.

异常

已释放了 TaskThe Task has been disposed.

-or- 创建了该标记的 CancellationTokenSource 已被释放。The CancellationTokenSource that created the token has already been disposed.

continuationFunction 参数为 null。The continuationFunction argument is null.

-or- scheduler 参数为 null。The scheduler argument is null.

continuationOptions 参数为 TaskContinuationOptions 指定无效值。The continuationOptions argument specifies an invalid value for TaskContinuationOptions.

示例

下面的示例演示如何将 System.threading.tasks.task.continuewith 方法与延续选项一起使用:The following example shows how to use the ContinueWith method with continuation options:

using System;
using System.Threading;
using System.Threading.Tasks;

class ContinuationOptionsDemo
{
    // Demonstrated features:
    //      TaskContinuationOptions
    //		Task.ContinueWith()
    // 		Task.Factory
    //		Task.Wait()
    // Expected results:
    // 		This sample demonstrates branched continuation sequences - Task+Commit or Task+Rollback.
    //      Notice that no if statements are used.
    //		The first sequence is successful - tran1 and commitTran1 are executed. rollbackTran1 is canceled.
    //		The second sequence is unsuccessful - tran2 and rollbackTran2 are executed. tran2 is faulted, and commitTran2 is canceled.
    // Documentation:
    //		http://msdn.microsoft.com/library/system.threading.tasks.taskcontinuationoptions(VS.100).aspx
    static void Main()
    {
        Action success = () => Console.WriteLine("Task={0}, Thread={1}: Begin successful transaction",
                                                Task.CurrentId, Thread.CurrentThread.ManagedThreadId);
        Action failure = () =>
        {
            Console.WriteLine("Task={0}, Thread={1}: Begin transaction and encounter an error",
                                Task.CurrentId, Thread.CurrentThread.ManagedThreadId);
            throw new InvalidOperationException("SIMULATED EXCEPTION");
        };

        Action<Task> commit = (antecendent) => Console.WriteLine("Task={0}, Thread={1}: Commit transaction",
                                                                Task.CurrentId, Thread.CurrentThread.ManagedThreadId);
        Action<Task> rollback = (antecendent) =>
        {
            // "Observe" your antecedent's exception so as to avoid an exception
            // being thrown on the finalizer thread
            var unused = antecendent.Exception;

            Console.WriteLine("Task={0}, Thread={1}: Rollback transaction",
                  Task.CurrentId, Thread.CurrentThread.ManagedThreadId);
        };

        // Successful transaction - Begin + Commit
        Console.WriteLine("Demonstrating a successful transaction");

        // Initial task
        // Treated as "fire-and-forget" -- any exceptions will be cleaned up in rollback continuation
        Task tran1 = Task.Factory.StartNew(success);

        // The following task gets scheduled only if tran1 completes successfully
        var commitTran1 = tran1.ContinueWith(commit, TaskContinuationOptions.OnlyOnRanToCompletion);

        // The following task gets scheduled only if tran1 DOES NOT complete successfully
        var rollbackTran1 = tran1.ContinueWith(rollback, TaskContinuationOptions.NotOnRanToCompletion);

        // For demo purposes, wait for the sample to complete
        commitTran1.Wait();

        // -----------------------------------------------------------------------------------


        // Failed transaction - Begin + exception + Rollback
        Console.WriteLine("\nDemonstrating a failed transaction");

        // Initial task
        // Treated as "fire-and-forget" -- any exceptions will be cleaned up in rollback continuation
        Task tran2 = Task.Factory.StartNew(failure);

        // The following task gets scheduled only if tran2 completes successfully
        var commitTran2 = tran2.ContinueWith(commit, TaskContinuationOptions.OnlyOnRanToCompletion);

        // The following task gets scheduled only if tran2 DOES NOT complete successfully
        var rollbackTran2 = tran2.ContinueWith(rollback, TaskContinuationOptions.NotOnRanToCompletion);

        // For demo purposes, wait for the sample to complete
        rollbackTran2.Wait();
    }

}
Imports System.Threading
Imports System.Threading.Tasks

Module ContuationOptionsDemo
    ' Demonstrated features:
    '   TaskContinuationOptions
    '   Task.ContinueWith()
    '   Task.Factory
    '   Task.Wait()
    ' Expected results:
    '   This sample demonstrates branched continuation sequences - Task+Commit or Task+Rollback.
    '   Notice that no if statements are used.
    '   The first sequence is successful - tran1 and commitTran1 are executed. rollbackTran1 is canceled.
    '   The second sequence is unsuccessful - tran2 and rollbackTran2 are executed. tran2 is faulted, and commitTran2 is canceled.
    ' Documentation:
    '   http://msdn.microsoft.com/library/system.threading.tasks.taskcontinuationoptions(VS.100).aspx
    Private Sub Main()
        Dim success As Action = Sub()
                                    Console.WriteLine("Task={0}, Thread={1}: Begin successful transaction", Task.CurrentId, Thread.CurrentThread.ManagedThreadId)
                                End Sub

        Dim failure As Action = Sub()
                                    Console.WriteLine("Task={0}, Thread={1}: Begin transaction and encounter an error", Task.CurrentId, Thread.CurrentThread.ManagedThreadId)
                                    Throw New InvalidOperationException("SIMULATED EXCEPTION")
                                End Sub

        Dim commit As Action(Of Task) = Sub(antecendent)
                                            Console.WriteLine("Task={0}, Thread={1}: Commit transaction", Task.CurrentId, Thread.CurrentThread.ManagedThreadId)
                                        End Sub

        Dim rollback As Action(Of Task) = Sub(antecendent)
                                              ' "Observe" your antecedent's exception so as to avoid an exception
                                              ' being thrown on the finalizer thread
                                              Dim unused = antecendent.Exception

                                              Console.WriteLine("Task={0}, Thread={1}: Rollback transaction", Task.CurrentId, Thread.CurrentThread.ManagedThreadId)
                                          End Sub

        ' Successful transaction - Begin + Commit
        Console.WriteLine("Demonstrating a successful transaction")

        ' Initial task
        ' Treated as "fire-and-forget" -- any exceptions will be cleaned up in rollback continuation
        Dim tran1 As Task = Task.Factory.StartNew(success)

        ' The following task gets scheduled only if tran1 completes successfully
        Dim commitTran1 = tran1.ContinueWith(commit, TaskContinuationOptions.OnlyOnRanToCompletion)

        ' The following task gets scheduled only if tran1 DOES NOT complete successfully
        Dim rollbackTran1 = tran1.ContinueWith(rollback, TaskContinuationOptions.NotOnRanToCompletion)

        ' For demo purposes, wait for the sample to complete
        commitTran1.Wait()

        ' -----------------------------------------------------------------------------------


        ' Failed transaction - Begin + exception + Rollback 
        Console.WriteLine(vbLf & "Demonstrating a failed transaction")

        ' Initial task
        ' Treated as "fire-and-forget" -- any exceptions will be cleaned up in rollback continuation
        Dim tran2 As Task = Task.Factory.StartNew(failure)

        ' The following task gets scheduled only if tran2 completes successfully
        Dim commitTran2 = tran2.ContinueWith(commit, TaskContinuationOptions.OnlyOnRanToCompletion)

        ' The following task gets scheduled only if tran2 DOES NOT complete successfully
        Dim rollbackTran2 = tran2.ContinueWith(rollback, TaskContinuationOptions.NotOnRanToCompletion)

        ' For demo purposes, wait for the sample to complete
        rollbackTran2.Wait()
    End Sub
End Module

注解

直到当前任务完成后,才会计划执行返回的 Task<TResult>The returned Task<TResult> will not be scheduled for execution until the current task has completed. 如果未满足通过 continuationOptions 参数指定的条件,则将取消延续任务,而不是计划。If the criteria specified through the continuationOptions parameter are not met, the continuation task will be canceled instead of scheduled.

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

创建一个在目标 Task 完成时异步执行的延续任务。Creates a continuation that executes asynchronously when the target Task completes. 延续任务接收调用方提供的状态信息,并使用指定的计划程序。The continuation receives caller-supplied state information and uses a specified scheduler.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, System::Object ^, TResult> ^ continuationFunction, System::Object ^ state, System::Threading::Tasks::TaskScheduler ^ scheduler);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object,TResult> continuationFunction, object state, System.Threading.Tasks.TaskScheduler scheduler);
member this.ContinueWith : Func<System.Threading.Tasks.Task, obj, 'Result> * obj * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task<'Result>
Public Function ContinueWith(Of TResult) (continuationFunction As Func(Of Task, Object, TResult), state As Object, scheduler As TaskScheduler) As Task(Of TResult)

类型参数

TResult

延续任务生成的结果的类型。The type of the result produced by the continuation.

参数

continuationFunction
Func<Task,Object,TResult>

Task 完成时要运行的函数。A function to run when the Task completes. 运行时,委托将作为一个自变量传递给完成的任务和调用方提供的状态对象。When run, the delegate will be passed the completed task and the caller-supplied state object as arguments.

state
Object

一个表示由该延续功能使用的数据的对象。An object representing data to be used by the continuation function.

scheduler
TaskScheduler

要与延续任务关联并用于其执行过程的 TaskSchedulerThe TaskScheduler to associate with the continuation task and to use for its execution.

返回

一个新的延续 Task<TResult>A new continuation Task<TResult>.

异常

scheduler 参数为 nullThe scheduler argument is null.

注解

在当前任务完成之后,将不会计划执行返回的 Task<TResult>,无论该任务完成的原因是成功完成,还是由于未经处理的异常而发生故障,或由于被取消而导致错误。The returned Task<TResult> will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

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

创建一个在目标 Task 完成时异步执行并返回一个值的延续任务。Creates a continuation that executes asynchronously when the target Task completes and returns a value. 延续任务接收调用方提供的状态信息和取消标记。The continuation receives caller-supplied state information and a cancellation token.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, System::Object ^, TResult> ^ continuationFunction, System::Object ^ state, System::Threading::CancellationToken cancellationToken);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object,TResult> continuationFunction, object state, System.Threading.CancellationToken cancellationToken);
member this.ContinueWith : Func<System.Threading.Tasks.Task, obj, 'Result> * obj * System.Threading.CancellationToken -> System.Threading.Tasks.Task<'Result>

类型参数

TResult

延续任务生成的结果的类型。The type of the result produced by the continuation.

参数

continuationFunction
Func<Task,Object,TResult>

Task 完成时要运行的函数。A function to run when the Task completes. 运行时,委托将作为一个自变量传递给完成的任务和调用方提供的状态对象。When run, the delegate will be passed the completed task and the caller-supplied state object as arguments.

state
Object

一个表示由该延续功能使用的数据的对象。An object representing data to be used by the continuation function.

cancellationToken
CancellationToken

将指派给新的延续任务的 CancellationTokenThe CancellationToken that will be assigned to the new continuation task.

返回

一个新的延续 Task<TResult>A new continuation Task<TResult>.

异常

continuationFunction 参数为 nullThe continuationFunction argument is null.

已释放提供的 CancellationTokenThe provided CancellationToken has already been disposed.

注解

在当前任务完成之后,将不会计划执行返回的 Task<TResult>,无论该任务完成的原因是成功完成,还是由于未经处理的异常而发生故障,或由于被取消而导致错误。The returned Task<TResult> will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

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

创建一个在目标 Task 完成并返回一个值时接收调用方提供的状态信息并以异步方式执行的延续任务。Creates a continuation that receives caller-supplied state information and executes asynchronously when the target Task completes and returns a value.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, System::Object ^, TResult> ^ continuationFunction, System::Object ^ state);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object,TResult> continuationFunction, object state);
member this.ContinueWith : Func<System.Threading.Tasks.Task, obj, 'Result> * obj -> System.Threading.Tasks.Task<'Result>
Public Function ContinueWith(Of TResult) (continuationFunction As Func(Of Task, Object, TResult), state As Object) As Task(Of TResult)

类型参数

TResult

延续任务生成的结果的类型。The type of the result produced by the continuation.

参数

continuationFunction
Func<Task,Object,TResult>

Task 完成时要运行的函数。A function to run when the Task completes. 运行时,将传递委托,如完成的任务一样,调用方提供的状态对象(如参数)。When run, the delegate will be passed the completed task and the caller-supplied state object as arguments.

state
Object

一个表示由该延续功能使用的数据的对象。An object representing data to be used by the continuation function.

返回

一个新的延续 Task<TResult>A new continuation Task<TResult>.

异常

continuationFunction 参数为 nullThe continuationFunction argument is null.

注解

在当前任务完成之后,将不会计划执行返回的 Task<TResult>,无论该任务完成的原因是成功完成,还是由于未经处理的异常而发生故障,或由于被取消而导致错误。The returned Task<TResult> will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

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

创建一个按照指定延续任务选项执行并返回一个值的延续任务。Creates a continuation that executes according to the specified continuation options and returns a value.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, TResult> ^ continuationFunction, System::Threading::Tasks::TaskContinuationOptions continuationOptions);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,TResult> continuationFunction, System.Threading.Tasks.TaskContinuationOptions continuationOptions);
member this.ContinueWith : Func<System.Threading.Tasks.Task, 'Result> * System.Threading.Tasks.TaskContinuationOptions -> System.Threading.Tasks.Task<'Result>
Public Function ContinueWith(Of TResult) (continuationFunction As Func(Of Task, TResult), continuationOptions As TaskContinuationOptions) As Task(Of TResult)

类型参数

TResult

延续任务生成的结果的类型。The type of the result produced by the continuation.

参数

continuationFunction
Func<Task,TResult>

根据 continuationOptions 中指定的条件运行函数。A function to run according to the condition specified in continuationOptions. 在运行时,委托将作为一个自变量传递给完成的任务。When run, the delegate will be passed the completed task as an argument.

continuationOptions
TaskContinuationOptions

用于设置计划延续任务的时间以及延续任务的工作方式的选项。Options for when the continuation is scheduled and how it behaves. 这包括条件(如 OnlyOnCanceled)和执行选项(如 ExecuteSynchronously)。This includes criteria, such as OnlyOnCanceled, as well as execution options, such as ExecuteSynchronously.

返回

一个新的延续 Task<TResult>A new continuation Task<TResult>.

异常

已释放了 TaskThe Task has been disposed.

continuationFunction 参数为 null。The continuationFunction argument is null.

continuationOptions 参数为 TaskContinuationOptions 指定无效值。The continuationOptions argument specifies an invalid value for TaskContinuationOptions.

注解

直到当前任务完成后,才会计划执行返回的 Task<TResult>The returned Task<TResult> will not be scheduled for execution until the current task has completed. 如果未满足通过 continuationOptions 参数指定的继续条件,则将取消延续任务,而不是计划。If the continuation criteria specified through the continuationOptions parameter are not met, the continuation task will be canceled instead of scheduled.

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

创建一个在目标 Task 完成时异步执行并返回一个值的延续任务。Creates a continuation that executes asynchronously when the target Task completes and returns a value. 延续任务收到取消标记。The continuation receives a cancellation token.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, TResult> ^ continuationFunction, System::Threading::CancellationToken cancellationToken);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,TResult> continuationFunction, System.Threading.CancellationToken cancellationToken);
member this.ContinueWith : Func<System.Threading.Tasks.Task, 'Result> * System.Threading.CancellationToken -> System.Threading.Tasks.Task<'Result>

类型参数

TResult

延续任务生成的结果的类型。The type of the result produced by the continuation.

参数

continuationFunction
Func<Task,TResult>

Task 完成时要运行的函数。A function to run when the Task completes. 在运行时,委托将作为一个自变量传递给完成的任务。When run, the delegate will be passed the completed task as an argument.

cancellationToken
CancellationToken

将指派给新的延续任务的 CancellationTokenThe CancellationToken that will be assigned to the new continuation task.

返回

一个新的延续 Task<TResult>A new continuation Task<TResult>.

异常

已释放了 TaskThe Task has been disposed.

-or- 创建了该标记的 CancellationTokenSource 已被释放。The CancellationTokenSource that created the token has already been disposed.

continuationFunction 参数为 null。The continuationFunction argument is null.

注解

在当前任务完成之后,将不会计划执行返回的 Task<TResult>,无论该任务完成的原因是成功完成,还是由于未经处理的异常而发生故障,或由于被取消而导致错误。The returned Task<TResult> will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

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

创建一个在目标 Task<TResult> 完成时异步执行并返回一个值的延续任务。Creates a continuation that executes asynchronously when the target Task<TResult> completes and returns a value.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, TResult> ^ continuationFunction);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,TResult> continuationFunction);
member this.ContinueWith : Func<System.Threading.Tasks.Task, 'Result> -> System.Threading.Tasks.Task<'Result>
Public Function ContinueWith(Of TResult) (continuationFunction As Func(Of Task, TResult)) As Task(Of TResult)

类型参数

TResult

延续任务生成的结果的类型。The type of the result produced by the continuation.

参数

continuationFunction
Func<Task,TResult>

Task<TResult> 完成时要运行的函数。A function to run when the Task<TResult> completes. 在运行时,委托将作为一个自变量传递给完成的任务。When run, the delegate will be passed the completed task as an argument.

返回

一个新的延续任务。A new continuation task.

异常

已释放了 TaskThe Task has been disposed.

continuationFunction 参数为 null。The continuationFunction argument is null.

示例

下面的示例演示如何使用 System.threading.tasks.task.continuewith 方法:The following example shows how to use the ContinueWith method:

using System;
using System.Threading;
using System.Threading.Tasks;

class ContinuationSimpleDemo
{
    // Demonstrated features:
    // 		Task.Factory
    //		Task.ContinueWith()
    //		Task.Wait()
    // Expected results:
    // 		A sequence of three unrelated tasks is created and executed in this order - alpha, beta, gamma.
    //		A sequence of three related tasks is created - each task negates its argument and passes is to the next task: 5, -5, 5 is printed.
    //		A sequence of three unrelated tasks is created where tasks have different types.
    // Documentation:
    //		http://msdn.microsoft.com/library/system.threading.tasks.taskfactory_members(VS.100).aspx
    static void Main()
    {
        Action<string> action =
            (str) =>
                Console.WriteLine("Task={0}, str={1}, Thread={2}", Task.CurrentId, str, Thread.CurrentThread.ManagedThreadId);

        // Creating a sequence of action tasks (that return no result).
        Console.WriteLine("Creating a sequence of action tasks (that return no result)");
        Task.Factory.StartNew(() => action("alpha"))
            .ContinueWith(antecendent => action("beta"))        // Antecedent data is ignored
            .ContinueWith(antecendent => action("gamma"))
            .Wait();


        Func<int, int> negate =
            (n) =>
            {
                Console.WriteLine("Task={0}, n={1}, -n={2}, Thread={3}", Task.CurrentId, n, -n, Thread.CurrentThread.ManagedThreadId);
                return -n;
            };

        // Creating a sequence of function tasks where each continuation uses the result from its antecendent
        Console.WriteLine("\nCreating a sequence of function tasks where each continuation uses the result from its antecendent");
        Task<int>.Factory.StartNew(() => negate(5))
            .ContinueWith(antecendent => negate(antecendent.Result))		// Antecedent result feeds into continuation
            .ContinueWith(antecendent => negate(antecendent.Result))
            .Wait();


        // Creating a sequence of tasks where you can mix and match the types
        Console.WriteLine("\nCreating a sequence of tasks where you can mix and match the types");
        Task<int>.Factory.StartNew(() => negate(6))
            .ContinueWith(antecendent => action("x"))
            .ContinueWith(antecendent => negate(7))
            .Wait();
    }
}
Imports System.Threading
Imports System.Threading.Tasks

Module ContinuationDemo

    ' Demonstrated features:
    '   Task.Factory
    '   Task.ContinueWith()
    '   Task.Wait()
    ' Expected results:
    '   A sequence of three unrelated tasks is created and executed in this order - alpha, beta, gamma.
    '   A sequence of three related tasks is created - each task negates its argument and passes is to the next task: 5, -5, 5 is printed.
    '   A sequence of three unrelated tasks is created where tasks have different types.
    ' Documentation:
    '   http://msdn.microsoft.com/library/system.threading.tasks.taskfactory_members(VS.100).aspx
    Sub Main()
        Dim action As Action(Of String) = Sub(str) Console.WriteLine("Task={0}, str={1}, Thread={2}", Task.CurrentId, str, Thread.CurrentThread.ManagedThreadId)

        ' Creating a sequence of action tasks (that return no result).
        Console.WriteLine("Creating a sequence of action tasks (that return no result)")
        ' Continuations ignore antecedent data
        Task.Factory.StartNew(Sub() action("alpha")).ContinueWith(Sub(antecendent) action("beta")).ContinueWith(Sub(antecendent) action("gamma")).Wait()


        Dim negate As Func(Of Integer, Integer) = Function(n)
                                                      Console.WriteLine("Task={0}, n={1}, -n={2}, Thread={3}", Task.CurrentId, n, -n, Thread.CurrentThread.ManagedThreadId)
                                                      Return -n
                                                  End Function

        ' Creating a sequence of function tasks where each continuation uses the result from its antecendent
        Console.WriteLine(vbLf & "Creating a sequence of function tasks where each continuation uses the result from its antecendent")
        Task(Of Integer).Factory.StartNew(Function() negate(5)).ContinueWith(Function(antecendent) negate(antecendent.Result)).ContinueWith(Function(antecendent) negate(antecendent.Result)).Wait()


        ' Creating a sequence of tasks where you can mix and match the types
        Console.WriteLine(vbLf & "Creating a sequence of tasks where you can mix and match the types")
        Task(Of Integer).Factory.StartNew(Function() negate(6)).ContinueWith(Sub(antecendent) action("x")).ContinueWith(Function(antecendent) negate(7)).Wait()
    End Sub
End Module

注解

在当前任务完成之后,将不会计划执行返回的 Task<TResult>,无论该任务完成的原因是成功完成,还是由于未经处理的异常而发生故障,或由于被取消而导致错误。The returned Task<TResult> will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

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

创建一个在目标 Task 完成时异步执行并返回一个值的延续任务。Creates a continuation that executes asynchronously when the target Task completes and returns a value. 延续任务使用指定计划程序。The continuation uses a specified scheduler.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, TResult> ^ continuationFunction, System::Threading::Tasks::TaskScheduler ^ scheduler);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,TResult> continuationFunction, System.Threading.Tasks.TaskScheduler scheduler);
member this.ContinueWith : Func<System.Threading.Tasks.Task, 'Result> * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task<'Result>
Public Function ContinueWith(Of TResult) (continuationFunction As Func(Of Task, TResult), scheduler As TaskScheduler) As Task(Of TResult)

类型参数

TResult

延续任务生成的结果的类型。The type of the result produced by the continuation.

参数

continuationFunction
Func<Task,TResult>

Task 完成时要运行的函数。A function to run when the Task completes. 在运行时,委托将作为一个自变量传递给完成的任务。When run, the delegate will be passed the completed task as an argument.

scheduler
TaskScheduler

要与延续任务关联并用于其执行过程的 TaskSchedulerThe TaskScheduler to associate with the continuation task and to use for its execution.

返回

一个新的延续 Task<TResult>A new continuation Task<TResult>.

异常

已释放了 TaskThe Task has been disposed.

continuationFunction 参数为 null。The continuationFunction argument is null.

-or- scheduler 参数为 null。The scheduler argument is null.

注解

在当前任务完成之后,将不会计划执行返回的 Task<TResult>,无论该任务完成的原因是成功完成,还是由于未经处理的异常而发生故障,或由于被取消而导致错误。The returned Task<TResult> will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

适用于