Task.ContinueWith 方法

定义

命名空间:

System.Threading.Tasks

程序集:

System.Runtime.dll

创建一个在目标 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

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

C#

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

参数

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

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

C#

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

参数

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 在后台和用户界面线程上运行工作的示例。

C#

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

注解

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

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

Source:

Task.cs

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

C#

public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object?> continuationAction, object? state, System.Threading.Tasks.TaskScheduler scheduler);

参数

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

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

C#

public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object?> continuationAction, object? state, System.Threading.Tasks.TaskContinuationOptions continuationOptions);

参数

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

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

C#

public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object?> continuationAction, object? state, System.Threading.CancellationToken cancellationToken);

参数

continuationAction

Action<Task,Object>

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

state

Object

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

cancellationToken

CancellationToken

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

返回

Task

一个新的延续 Task。

例外

ArgumentNullException

continuationAction 参数为 null。

ObjectDisposedException

已释放提供的 CancellationToken。

注解

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

ContinueWith(Action<Task>)

Source:

Task.cs

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

C#

public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task> continuationAction);

参数

continuationAction

Action<Task>

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

返回

Task

一个新的延续 Task。

例外

ArgumentNullException

continuationAction 参数为 null。

示例

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

C#

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

由于控制台应用程序可能在延续任务执行之前终止， Wait() 因此调用 方法以确保延续在示例结束之前完成执行。

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

注解

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

ContinueWith(Action<Task>, TaskContinuationOptions)

Source:

Task.cs

创建一个在目标任务完成时按照指定的 TaskContinuationOptions 执行的延续任务。

C#

public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task> continuationAction, System.Threading.Tasks.TaskContinuationOptions continuationOptions);

参数

continuationAction

Action<Task>

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

continuationOptions

TaskContinuationOptions

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

返回

Task

一个新的延续 Task。

例外

ArgumentNullException

continuationAction 参数为 null。

ArgumentOutOfRangeException

continuationOptions 参数为 TaskContinuationOptions 指定无效值。

示例

下面的示例演示如何使用 TaskContinuationOptions 指定延续任务应在前面的任务完成时同步运行。 (如果指定的任务在调用时 ContinueWith 已完成，则同步延续将在调用 ContinueWith.)

C#

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

注解

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

ContinueWith(Action<Task>, CancellationToken)

Source:

Task.cs

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

C#

public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task> continuationAction, System.Threading.CancellationToken cancellationToken);

参数

continuationAction

Action<Task>

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

cancellationToken

CancellationToken

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

返回

Task

一个新的延续 Task。

例外

ObjectDisposedException

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

ArgumentNullException

continuationAction 参数为 null。

注解

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

ContinueWith(Action<Task,Object>, Object)

Source:

Task.cs

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

C#

public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object?> continuationAction, object? state);

参数

continuationAction

Action<Task,Object>

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

state

Object

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

返回

Task

一个新的延续任务。

例外

ArgumentNullException

continuationAction 参数为 null。

注解

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

ContinueWith(Action<Task>, TaskScheduler)

Source:

Task.cs

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

C#

public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task> continuationAction, System.Threading.Tasks.TaskScheduler scheduler);

参数

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

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

C#

public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object?,TResult> continuationFunction, object? state, System.Threading.Tasks.TaskScheduler scheduler);

类型参数

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

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

C#

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

类型参数

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

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

C#

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

类型参数

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 方法与延续选项一起使用：

C#

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

注解

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

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

Source:

Task.cs

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

C#

public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object?,TResult> continuationFunction, object? state, System.Threading.CancellationToken cancellationToken);

类型参数

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

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

C#

public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object?,TResult> continuationFunction, object? state, System.Threading.Tasks.TaskContinuationOptions continuationOptions);

类型参数

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

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

C#

public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,TResult> continuationFunction, System.Threading.Tasks.TaskContinuationOptions continuationOptions);

类型参数

TResult

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

参数

continuationFunction

Func<Task,TResult>

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

continuationOptions

TaskContinuationOptions

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

返回

Task<TResult>

一个新的延续 Task<TResult>。

例外

ObjectDisposedException

已释放了 Task。

ArgumentNullException

continuationFunction 参数为 null。

ArgumentOutOfRangeException

continuationOptions 参数为 TaskContinuationOptions 指定无效值。

注解

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

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

Source:

Task.cs

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

C#

public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,TResult> continuationFunction, System.Threading.Tasks.TaskScheduler scheduler);

类型参数

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

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

C#

public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,TResult> continuationFunction, System.Threading.CancellationToken cancellationToken);

类型参数

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

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

C#

public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object?,TResult> continuationFunction, object? state);

类型参数

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

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

C#

public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,TResult> continuationFunction);

类型参数

TResult

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

参数

continuationFunction

Func<Task,TResult>

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

返回

Task<TResult>

一个新的延续任务。

例外

ObjectDisposedException

已释放了 Task。

ArgumentNullException

continuationFunction 参数为 null。

示例

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

C#

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

注解

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