Task.ContinueWith 方法

参考

定义

命名空间:: System.Threading.Tasks

程序集:: System.Threading.Tasks.dll

程序集:: System.Runtime.dll

程序集:: mscorlib.dll

程序集:: netstandard.dll

重要

一些信息与预发行产品相关，相应产品在发行之前可能会进行重大修改。对于此处提供的信息，Microsoft 不作任何明示或暗示的担保。

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

重载

ContinueWith(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	创建一个在目标 Task 完成时接收调用方提供的状态信息和取消标记并执行的延续任务。延续任务根据一组指定的条件执行，并使用指定的计划程序。
ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler)	创建一个在目标任务完成时按照指定的 TaskContinuationOptions 执行的延续任务。延续任务会收到一个取消标记，并使用指定的计划程序。
ContinueWith(Action<Task,Object>, Object, TaskScheduler)	创建一个在目标 Task 完成时接收调用方提供的状态信息并以异步方式执行的延续任务。延续任务使用指定计划程序。
ContinueWith(Action<Task,Object>, Object, TaskContinuationOptions)	创建一个在目标 Task 完成时接收调用方提供的状态信息并执行的延续任务。延续任务根据一组指定的条件执行。
ContinueWith(Action<Task,Object>, Object, CancellationToken)	创建一个在目标 Task 完成时接收调用方提供的状态信息和取消标记，并以异步方式执行的延续任务。
ContinueWith(Action<Task>)	创建一个在目标 Task 完成时异步执行的延续任务。
ContinueWith(Action<Task>, TaskContinuationOptions)	创建一个在目标任务完成时按照指定的 TaskContinuationOptions 执行的延续任务。
ContinueWith(Action<Task>, CancellationToken)	创建一个在目标 Task 完成时可接收取消标记并以异步方式执行的延续任务。
ContinueWith(Action<Task,Object>, Object)	创建一个在目标 Task 完成时接收调用方提供的状态信息并执行的延续任务。
ContinueWith(Action<Task>, TaskScheduler)	创建一个在目标 Task 完成时异步执行的延续任务。延续任务使用指定计划程序。
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskScheduler)	创建一个在目标 Task 完成时异步执行的延续任务。延续任务接收调用方提供的状态信息，并使用指定的计划程序。
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	创建一个在目标 Task 完成并返回一个值时根据指定的任务延续选项执行的延续任务。延续任务接收调用方提供的状态信息和取消标记，并使用指定的计划程序。
ContinueWith<TResult>(Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	创建一个按照指定延续任务选项执行并返回一个值的延续任务。延续任务被传入一个取消标记，并使用指定的计划程序。
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken)	创建一个在目标 Task 完成时异步执行并返回一个值的延续任务。延续任务接收调用方提供的状态信息和取消标记。
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskContinuationOptions)	创建一个在目标 Task 完成时根据指定的任务延续选项执行的延续任务。延续任务接收调用方提供的状态信息。
ContinueWith<TResult>(Func<Task,TResult>, TaskContinuationOptions)	创建一个按照指定延续任务选项执行并返回一个值的延续任务。
ContinueWith<TResult>(Func<Task,TResult>, TaskScheduler)	创建一个在目标 Task 完成时异步执行并返回一个值的延续任务。延续任务使用指定计划程序。
ContinueWith<TResult>(Func<Task,TResult>, CancellationToken)	创建一个在目标 Task 完成时异步执行并返回一个值的延续任务。延续任务收到取消标记。
ContinueWith<TResult>(Func<Task,Object,TResult>, Object)	创建一个在目标 Task 完成并返回一个值时接收调用方提供的状态信息并以异步方式执行的延续任务。
ContinueWith<TResult>(Func<Task,TResult>)	创建一个在目标 Task<TResult> 完成时异步执行并返回一个值的延续任务。

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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

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

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

Public Function ContinueWith (continuationAction As Action(Of Task, Object), state As Object, cancellationToken As CancellationToken, continuationOptions As TaskContinuationOptions, scheduler As TaskScheduler) As Task

参数

continuationAction: Action<Task,Object>

在 Task 完成时要运行的操作。运行时，将传递委托，如完成的任务一样，调用方提供的状态对象（如参数）。

state: Object

一个表示由该延续操作使用的数据的对象。

cancellationToken: CancellationToken

将指派给新的延续任务的 CancellationToken。

continuationOptions: TaskContinuationOptions

用于设置计划延续任务的时间以及延续任务的工作方式的选项。这包括条件（如 OnlyOnCanceled）和执行选项（如 ExecuteSynchronously）。

scheduler: TaskScheduler

要与延续任务关联并用于其执行过程的 TaskScheduler。

Task

一个新的延续 Task。

例外

ArgumentNullException

scheduler 参数为 null。

ArgumentOutOfRangeException

continuationOptions 参数为 TaskContinuationOptions 指定无效值。

ObjectDisposedException

已释放提供的 CancellationToken。

注解

在当前任务完成之前，不会计划返回 Task 的执行。如果不满足通过 continuationOptions 参数指定的条件，则会取消延续任务，而不是计划任务。

适用于

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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

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

Public Function ContinueWith (continuationAction As Action(Of Task), cancellationToken As CancellationToken, continuationOptions As TaskContinuationOptions, scheduler As TaskScheduler) As Task

参数

continuationAction: Action<Task>

根据在 continuationOptions 中指定的条件运行的操作。在运行时，委托将作为一个自变量传递给完成的任务。

cancellationToken: CancellationToken

将指派给新的延续任务的 CancellationToken。

continuationOptions: TaskContinuationOptions

用于设置计划延续任务的时间以及延续任务的工作方式的选项。这包括条件（如 OnlyOnCanceled）和执行选项（如 ExecuteSynchronously）。

scheduler: TaskScheduler

要与延续任务关联并用于其执行过程的 TaskScheduler。

Task

一个新的延续 Task。

例外

ObjectDisposedException

创建了该标记的 CancellationTokenSource 已被释放。

ArgumentNullException

continuationAction 参数为 null。

- 或 -

scheduler 参数为 null。

ArgumentOutOfRangeException

continuationOptions 参数为 TaskContinuationOptions 指定无效值。

示例

下面是使用 ContinueWith 在后台和用户界面线程上运行工作的示例。

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

注解

在当前任务完成之前，不会计划返回 Task 的执行。如果不满足通过 continuationOptions 参数指定的条件，则会取消延续任务，而不是计划任务。

适用于

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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

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

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 完成时要运行的操作。运行时，将传递委托，如完成的任务一样，调用方提供的状态对象（如参数）。

state: Object

一个表示由该延续操作使用的数据的对象。

scheduler: TaskScheduler

要与延续任务关联并用于其执行过程的 TaskScheduler。

Task

一个新的延续 Task。

例外

ArgumentNullException

scheduler 参数为 null。

注解

返回的 Task 不会计划执行，直到当前任务完成，无论是由于运行成功完成而完成，由于未处理的异常而出错，还是由于取消而提前退出。

适用于

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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

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

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 完成时要运行的操作。运行时，将传递委托，如完成的任务一样，调用方提供的状态对象（如参数）。

state: Object

一个表示由该延续操作使用的数据的对象。

continuationOptions: TaskContinuationOptions

用于设置计划延续任务的时间以及延续任务的工作方式的选项。这包括条件（如 OnlyOnCanceled）和执行选项（如 ExecuteSynchronously）。

Task

一个新的延续 Task。

例外

ArgumentNullException

continuationAction 参数为 null。

ArgumentOutOfRangeException

continuationOptions 参数为 TaskContinuationOptions 指定无效值。

注解

在当前任务完成之前，不会计划返回 Task 的执行。如果不满足通过 continuationOptions 参数指定的延续条件，则将取消延续任务，而不是计划延续任务。

适用于

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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

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

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

Public Function ContinueWith (continuationAction As Action(Of Task, Object), state As Object, cancellationToken As CancellationToken) As Task

参数

continuationAction: Action<Task,Object>

在 Task 完成时要运行的操作。运行时，将传递委托，如完成的任务一样，调用方提供的状态对象（如参数）。

state: Object

一个表示由该延续操作使用的数据的对象。

cancellationToken: CancellationToken

将指派给新的延续任务的 CancellationToken。

Task

一个新的延续 Task。

例外

ArgumentNullException

continuationAction 参数为 null。

ObjectDisposedException

已释放提供的 CancellationToken。

注解

返回的 Task 不会计划执行，直到当前任务完成，无论是由于运行成功完成而完成，由于未处理的异常而出错，还是由于取消而提前退出。

适用于

ContinueWith(Action<Task>)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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

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 完成时要运行的操作。在运行时，委托将作为一个自变量传递给完成的任务。

Task

一个新的延续 Task。

例外

ArgumentNullException

continuationAction 参数为 null。

示例

以下示例定义一个任务，该任务使用 100 个随机日期和时间值填充数组。它使用 ContinueWith(Action<Task>) 方法在完全填充数组后选择最早和最新的日期值。

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

open System
open System.Threading.Tasks

let firstTask =
    Task.Factory.StartNew(fun () ->
        let rnd = Random()
        let dates = Array.zeroCreate 100
        let buffer = Array.zeroCreate 8
        let mutable i = dates.GetLowerBound 0

        while i <= dates.GetUpperBound 0 do
            rnd.NextBytes buffer
            let ticks = BitConverter.ToInt64(buffer, 0)

            if ticks > DateTime.MinValue.Ticks && ticks < DateTime.MaxValue.Ticks then
                dates[i] <- DateTime ticks
                i <- i + 1

        dates)

let continuationTask =
    firstTask.ContinueWith(
        Action<Task<DateTime[]>>(fun antecedent ->
            let dates: DateTime[] = antecedent.Result
            let mutable earliest = dates[0]
            let mutable latest = earliest

            for i = dates.GetLowerBound 0 + 1 to dates.GetUpperBound 0 do
                if dates.[i] < earliest then
                    earliest <- dates.[i]

                if dates.[i] > latest then
                    latest <- dates.[i]

            printfn $"Earliest date: {earliest}"
            printfn $"Latest date: {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() 因此调用方法以确保延续在示例结束之前完成执行。

有关其他示例，请参阅使用延续任务链接任务。

注解

返回的 Task 不会计划执行，直到当前任务完成，无论是由于运行成功完成而完成，由于未处理的异常而出错，还是由于取消而提前退出。

适用于

ContinueWith(Action<Task>, TaskContinuationOptions)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

创建一个在目标任务完成时按照指定的 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 中指定的条件运行的操作。在运行时，委托将作为一个自变量传递给完成的任务。

continuationOptions: TaskContinuationOptions

用于设置计划延续任务的时间以及延续任务的工作方式的选项。这包括条件（如 OnlyOnCanceled）和执行选项（如 ExecuteSynchronously）。

Task

一个新的延续 Task。

例外

ArgumentNullException

continuationAction 参数为 null。

ArgumentOutOfRangeException

continuationOptions 参数为 TaskContinuationOptions 指定无效值。

示例

下面的示例演示如何使用 TaskContinuationOptions 指定延续任务应在前面的任务完成时同步运行。 (如果指定的任务在调用时 ContinueWith 已完成，则同步延续将在调用 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

注解

在当前任务完成之前，不会计划返回 Task 的执行。如果不满足通过 continuationOptions 参数指定的延续条件，则将取消延续任务，而不是计划延续任务。

适用于

ContinueWith(Action<Task>, CancellationToken)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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

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

Public Function ContinueWith (continuationAction As Action(Of Task), cancellationToken As CancellationToken) As Task

参数

continuationAction: Action<Task>

在 Task 完成时要运行的操作。在运行时，委托将作为一个自变量传递给完成的任务。

cancellationToken: CancellationToken

将指派给新的延续任务的 CancellationToken。

Task

一个新的延续 Task。

例外

ObjectDisposedException

创建了该标记的 CancellationTokenSource 已被释放。

ArgumentNullException

continuationAction 参数为 null。

注解

返回的 Task 不会计划执行，直到当前任务完成，无论是由于运行成功完成而完成，由于未处理的异常而出错，还是由于取消而提前退出。

适用于

ContinueWith(Action<Task,Object>, Object)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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

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

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>

在任务完成时要运行的操作。运行时，委托作为一个自变量传递给完成的任务和调用方提供的状态对象。

state: Object

一个表示由该延续操作使用的数据的对象。

Task

一个新的延续任务。

例外

ArgumentNullException

continuationAction 参数为 null。

注解

返回的 Task 在当前任务完成之前不会计划执行，无论是由于运行到成功完成、由于未处理的异常而出错，还是由于取消而提前退出。

适用于

ContinueWith(Action<Task>, TaskScheduler)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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

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 完成时要运行的操作。在运行时，委托将作为一个自变量传递给完成的任务。

scheduler: TaskScheduler

要与延续任务关联并用于其执行过程的 TaskScheduler。

Task

一个新的延续 Task。

例外

ObjectDisposedException

已释放了 Task。

ArgumentNullException

continuationAction 参数为 null。

- 或 -

scheduler 参数为 null。

注解

返回的 Task 不会计划执行，直到当前任务完成，无论是由于运行成功完成而完成，由于未处理的异常而出错，还是由于取消而提前退出。

适用于

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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

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

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

延续任务生成的结果的类型。

参数

continuationFunction: Func<Task,Object,TResult>

在 Task 完成时要运行的函数。运行时，将传递委托，如完成的任务一样，调用方提供的状态对象（如参数）。

state: Object

一个表示由该延续功能使用的数据的对象。

scheduler: TaskScheduler

要与延续任务关联并用于其执行过程的 TaskScheduler。

Task<TResult>

一个新的延续 Task<TResult>。

例外

ArgumentNullException

scheduler 参数为 null。

注解

返回的 Task<TResult> 不会计划执行，直到当前任务完成，无论是由于运行成功完成而完成，由于未处理的异常而出错，还是由于取消而提前退出。

适用于

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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

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

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>

Public Function ContinueWith(Of TResult) (continuationFunction As Func(Of Task, Object, TResult), state As Object, cancellationToken As CancellationToken, continuationOptions As TaskContinuationOptions, scheduler As TaskScheduler) As Task(Of TResult)

类型参数

TResult

延续任务生成的结果的类型。

参数

continuationFunction: Func<Task,Object,TResult>

在 Task 完成时要运行的函数。运行时，将传递委托，如完成的任务一样，调用方提供的状态对象（如参数）。

state: Object

一个表示由该延续功能使用的数据的对象。

cancellationToken: CancellationToken

将指派给新的延续任务的 CancellationToken。

continuationOptions: TaskContinuationOptions

用于设置计划延续任务的时间以及延续任务的工作方式的选项。这包括条件（如 OnlyOnCanceled）和执行选项（如 ExecuteSynchronously）。

scheduler: TaskScheduler

要与延续任务关联并用于其执行过程的 TaskScheduler。

Task<TResult>

一个新的延续 Task<TResult>。

例外

ArgumentNullException

scheduler 参数为 null。

ArgumentOutOfRangeException

continuationOptions 参数为 TaskContinuationOptions 指定无效值。

ObjectDisposedException

已释放提供的 CancellationToken。

注解

在当前任务完成之前，不会计划返回 Task<TResult> 的执行。如果不满足通过 continuationOptions 参数指定的条件，则将取消延续任务，而不是计划任务。

适用于

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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

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>

Public Function ContinueWith(Of TResult) (continuationFunction As Func(Of Task, TResult), cancellationToken As CancellationToken, continuationOptions As TaskContinuationOptions, scheduler As TaskScheduler) As Task(Of TResult)

类型参数

TResult

延续任务生成的结果的类型。

参数

continuationFunction: Func<Task,TResult>

要根据指定的 continuationOptions. “运行时间”运行的函数，委托将作为参数传递已完成的任务。

cancellationToken: CancellationToken

将指派给新的延续任务的 CancellationToken。

continuationOptions: TaskContinuationOptions

用于设置计划延续任务的时间以及延续任务的工作方式的选项。这包括条件（如 OnlyOnCanceled）和执行选项（如 ExecuteSynchronously）。

scheduler: TaskScheduler

要与延续任务关联并用于其执行过程的 TaskScheduler。

Task<TResult>

一个新的延续 Task<TResult>。

例外

ObjectDisposedException

已释放了 Task。

- 或 -

创建了该标记的 CancellationTokenSource 已被释放。

ArgumentNullException

continuationFunction 参数为 null。

- 或 -

scheduler 参数为 null。

ArgumentOutOfRangeException

continuationOptions 参数为 TaskContinuationOptions 指定无效值。

示例

以下示例演示如何将 ContinueWith 方法与延续选项一起使用：

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

open System
open System.Threading
open System.Threading.Tasks

// 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
let success =
    fun () ->
        printfn $"Task={Task.CurrentId}, Thread={Thread.CurrentThread.ManagedThreadId}: Begin successful transaction"

let failure =
    fun () ->

        printfn
            $"Task={Task.CurrentId}, Thread={Thread.CurrentThread.ManagedThreadId}: Begin transaction and encounter an error"

        raise (InvalidOperationException "SIMULATED EXCEPTION")

let commit =
    fun antecendent ->
        printfn $"Task={Task.CurrentId}, Thread={Thread.CurrentThread.ManagedThreadId}: Commit transaction"

let rollback =
    fun (antecendent: Task) ->

        // "Observe" your antecedent's exception so as to avoid an exception
        // being thrown on the finalizer thread
        let unused = antecendent.Exception

        printfn $"Task={Task.CurrentId}, Thread={Thread.CurrentThread.ManagedThreadId}: Rollback transaction"

// Successful transaction - Begin + Commit
printfn "Demonstrating a successful transaction"

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

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

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

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

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

// Failed transaction - Begin + exception + Rollback
printfn "\nDemonstrating a failed transaction"

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

// The following task gets scheduled only if tran2 completes successfully
let commitTran2 =
    tran2.ContinueWith(Action<Task> commit, TaskContinuationOptions.OnlyOnRanToCompletion)

// The following task gets scheduled only if tran2 DOES NOT complete successfully
let rollbackTran2 =
    tran2.ContinueWith(Action<Task> 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> 的执行。如果不满足通过 continuationOptions 参数指定的条件，则将取消延续任务，而不是计划任务。

适用于

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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

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

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>

Public Function ContinueWith(Of TResult) (continuationFunction As Func(Of Task, Object, TResult), state As Object, cancellationToken As CancellationToken) As Task(Of TResult)

类型参数

TResult

延续任务生成的结果的类型。

参数

continuationFunction: Func<Task,Object,TResult>

在 Task 完成时要运行的函数。运行时，将传递委托，如完成的任务一样，调用方提供的状态对象（如参数）。

state: Object

一个表示由该延续功能使用的数据的对象。

cancellationToken: CancellationToken

将指派给新的延续任务的 CancellationToken。

Task<TResult>

一个新的延续 Task<TResult>。

例外

ArgumentNullException

continuationFunction 参数为 null。

ObjectDisposedException

已释放提供的 CancellationToken。

注解

返回的 Task<TResult> 不会计划执行，直到当前任务完成，无论是由于运行成功完成而完成，由于未处理的异常而出错，还是由于取消而提前退出。

适用于

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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

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

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

延续任务生成的结果的类型。

参数

continuationFunction: Func<Task,Object,TResult>

在 Task 完成时要运行的函数。运行时，将传递委托，如完成的任务一样，调用方提供的状态对象（如参数）。

state: Object

一个表示由该延续功能使用的数据的对象。

continuationOptions: TaskContinuationOptions

用于设置计划延续任务的时间以及延续任务的工作方式的选项。这包括条件（如 OnlyOnCanceled）和执行选项（如 ExecuteSynchronously）。

Task<TResult>

一个新的延续 Task<TResult>。

例外

ArgumentNullException

continuationFunction 参数为 null。

ArgumentOutOfRangeException

continuationOptions 参数为 TaskContinuationOptions 指定无效值。

注解

在当前任务完成之前，不会计划返回 Task<TResult> 的执行。如果不满足通过 continuationOptions 参数指定的延续条件，则将取消延续任务，而不是计划延续任务。

适用于

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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

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

延续任务生成的结果的类型。

参数

continuationFunction: Func<Task,TResult>

根据 continuationOptions 中指定的条件运行函数。在运行时，委托将作为一个自变量传递给完成的任务。

continuationOptions: TaskContinuationOptions

用于设置计划延续任务的时间以及延续任务的工作方式的选项。这包括条件（如 OnlyOnCanceled）和执行选项（如 ExecuteSynchronously）。

Task<TResult>

一个新的延续 Task<TResult>。

例外

ObjectDisposedException

已释放了 Task。

ArgumentNullException

continuationFunction 参数为 null。

ArgumentOutOfRangeException

continuationOptions 参数为 TaskContinuationOptions 指定无效值。

注解

适用于

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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

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

延续任务生成的结果的类型。

参数

continuationFunction: Func<Task,TResult>

在 Task 完成时要运行的函数。在运行时，委托将作为一个自变量传递给完成的任务。

scheduler: TaskScheduler

要与延续任务关联并用于其执行过程的 TaskScheduler。

Task<TResult>

一个新的延续 Task<TResult>。

例外

ObjectDisposedException

已释放了 Task。

ArgumentNullException

continuationFunction 参数为 null。

- 或 -

scheduler 参数为 null。

注解

返回的 Task<TResult> 不会计划执行，直到当前任务完成，无论是由于运行成功完成而完成，由于未处理的异常而出错，还是由于取消而提前退出。

适用于

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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

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>

Public Function ContinueWith(Of TResult) (continuationFunction As Func(Of Task, TResult), cancellationToken As CancellationToken) As Task(Of TResult)

类型参数

TResult

延续任务生成的结果的类型。

参数

continuationFunction: Func<Task,TResult>

在 Task 完成时要运行的函数。在运行时，委托将作为一个自变量传递给完成的任务。

cancellationToken: CancellationToken

将指派给新的延续任务的 CancellationToken。

Task<TResult>

一个新的延续 Task<TResult>。

例外

ObjectDisposedException

已释放了 Task。

- 或 -

创建了该标记的 CancellationTokenSource 已被释放。

ArgumentNullException

continuationFunction 参数为 null。

注解

返回的 Task<TResult> 不会计划执行，直到当前任务完成，无论是由于运行成功完成而完成，由于未处理的异常而出错，还是由于取消而提前退出。

适用于

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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

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

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

延续任务生成的结果的类型。

参数

continuationFunction: Func<Task,Object,TResult>

在 Task 完成时要运行的函数。运行时，将传递委托，如完成的任务一样，调用方提供的状态对象（如参数）。

state: Object

一个表示由该延续功能使用的数据的对象。

Task<TResult>

一个新的延续 Task<TResult>。

例外

ArgumentNullException

continuationFunction 参数为 null。

注解

返回的 Task<TResult> 不会计划执行，直到当前任务完成，无论是由于运行成功完成而完成，由于未处理的异常而出错，还是由于取消而提前退出。

适用于

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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

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

延续任务生成的结果的类型。

参数

continuationFunction: Func<Task,TResult>

在 Task<TResult> 完成时要运行的函数。在运行时，委托将作为一个自变量传递给完成的任务。

Task<TResult>

一个新的延续任务。

例外

ObjectDisposedException

已释放了 Task。

ArgumentNullException

continuationFunction 参数为 null。

示例

以下示例演示如何使用 ContinueWith 方法：

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

open System
open System.Threading
open System.Threading.Tasks

// 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
let action =
    fun str -> printfn $"Task={Task.CurrentId}, str=%s{str}, Thread={Thread.CurrentThread.ManagedThreadId}"

// Creating a sequence of action tasks (that return no result).
printfn "Creating a sequence of action tasks (that return no result)"

Task
    .Factory
    .StartNew(fun () -> action "alpha")
    .ContinueWith(fun antecendent -> action "beta") // Antecedent data is ignored
    .ContinueWith(fun antecendent -> action "gamma")
    .Wait()

let negate =
    fun n ->
        printfn $"Task={Task.CurrentId}, n={n}, -n={2 - n}, Thread={Thread.CurrentThread.ManagedThreadId}"
        -n

// Creating a sequence of function tasks where each continuation uses the result from its antecendent
printfn "\nCreating a sequence of function tasks where each continuation uses the result from its antecendent"

Task<int>
    .Factory.StartNew(fun () -> negate 5)
    .ContinueWith(Func<Task<int>, int>(fun antecedent -> negate antecedent.Result)) // Antecedent result feeds into continuation
    .ContinueWith(Func<Task<int>, int>(fun antecedent -> negate antecedent.Result))
    .Wait()

// Creating a sequence of tasks where you can mix and match the types
printfn "\nCreating a sequence of tasks where you can mix and match the types"

Task<int>
    .Factory.StartNew(fun () -> negate 6)
    .ContinueWith(Action<Task>(fun antecendent -> action "x"))
    .ContinueWith(fun 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> 不会计划执行，直到当前任务完成，无论是由于运行成功完成而完成，由于未处理的异常而出错，还是由于取消而提前退出。

适用于