Task<TResult>.ContinueWith 方法

参考

定义

命名空间:: System.Threading.Tasks

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

程序集:: System.Runtime.dll

程序集:: mscorlib.dll

程序集:: netstandard.dll

重要

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

创建当另一任务完成时可以执行的延续任务。

重载

ContinueWith(Action<Task<TResult>,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	创建一个在目标 Task<TResult> 完成时执行的延续任务。
ContinueWith(Action<Task<TResult>,Object>, Object, TaskScheduler)	创建一个在目标 Task<TResult> 完成时执行的延续任务。
ContinueWith(Action<Task<TResult>,Object>, Object, TaskContinuationOptions)	创建一个在目标 Task<TResult> 完成时执行的延续任务。
ContinueWith(Action<Task<TResult>,Object>, Object, CancellationToken)	创建一个在目标 Task<TResult> 完成时执行的延续任务。
ContinueWith(Action<Task<TResult>>, CancellationToken, TaskContinuationOptions, TaskScheduler)	创建根据 `continuationOptions` 中指定的条件加以执行的延续任务。
ContinueWith(Action<Task<TResult>>, TaskContinuationOptions)	创建根据 `continuationOptions` 中指定的条件加以执行的延续任务。
ContinueWith(Action<Task<TResult>>, CancellationToken)	创建一个在目标 Task<TResult> 完成时异步执行的可取消延续任务。
ContinueWith(Action<Task<TResult>,Object>, Object)	创建一个传递有状态信息并在目标 Task<TResult> 完成时执行的延续。
ContinueWith(Action<Task<TResult>>)	创建一个在目标任务完成时异步执行的延续任务。
ContinueWith(Action<Task<TResult>>, TaskScheduler)	创建一个在目标 Task<TResult> 完成时异步执行的延续任务。
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	创建一个在目标 Task<TResult> 完成时执行的延续任务。
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	创建根据 `continuationOptions` 中指定的条件加以执行的延续任务。
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, TaskScheduler)	创建一个在目标 Task<TResult> 完成时执行的延续任务。
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, CancellationToken)	创建一个在目标 Task<TResult> 完成时执行的延续任务。
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, TaskContinuationOptions)	创建一个在目标 Task<TResult> 完成时执行的延续任务。
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, TaskContinuationOptions)	创建根据 `continuationOptions` 中指定的条件加以执行的延续任务。
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, CancellationToken)	创建一个在目标 Task<TResult> 完成时异步执行的延续任务。
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object)	创建一个在目标 Task<TResult> 完成时执行的延续任务。
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>)	创建一个在目标 Task<TResult> 完成时异步执行的延续任务。
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, TaskScheduler)	创建一个在目标 Task<TResult> 完成时异步执行的延续任务。

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

Source:: Future.cs

Source:: Future.cs

Source:: Future.cs

创建一个在目标 Task<TResult> 完成时执行的延续任务。

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task<TResult> ^, 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<TResult>,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<TResult>,object?> continuationAction, object? state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);

override this.ContinueWith : Action<System.Threading.Tasks.Task<'Result>, 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(Of TResult), Object), state As Object, cancellationToken As CancellationToken, continuationOptions As TaskContinuationOptions, scheduler As TaskScheduler) As Task

参数

continuationAction: Action<Task<TResult>,Object>

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

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<TResult>,Object>, Object, TaskScheduler)

Source:: Future.cs

Source:: Future.cs

Source:: Future.cs

创建一个在目标 Task<TResult> 完成时执行的延续任务。

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task<TResult> ^, System::Object ^> ^ continuationAction, System::Object ^ state, System::Threading::Tasks::TaskScheduler ^ scheduler);

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

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

override this.ContinueWith : Action<System.Threading.Tasks.Task<'Result>, obj> * obj * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task

Public Function ContinueWith (continuationAction As Action(Of Task(Of TResult), Object), state As Object, scheduler As TaskScheduler) As Task

参数

continuationAction: Action<Task<TResult>,Object>

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

state: Object

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

scheduler: TaskScheduler

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

Task

一个新的延续 Task。

例外

ArgumentNullException

scheduler 参数为 null。

注解

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

另请参阅

使用延续任务来链接任务

适用于

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

Source:: Future.cs

Source:: Future.cs

Source:: Future.cs

创建一个在目标 Task<TResult> 完成时执行的延续任务。

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task<TResult> ^, System::Object ^> ^ continuationAction, System::Object ^ state, System::Threading::Tasks::TaskContinuationOptions continuationOptions);

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

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

override this.ContinueWith : Action<System.Threading.Tasks.Task<'Result>, obj> * obj * System.Threading.Tasks.TaskContinuationOptions -> System.Threading.Tasks.Task

Public Function ContinueWith (continuationAction As Action(Of Task(Of TResult), Object), state As Object, continuationOptions As TaskContinuationOptions) As Task

参数

continuationAction: Action<Task<TResult>,Object>

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

state: Object

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

continuationOptions: TaskContinuationOptions

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

Task

一个新的延续 Task。

例外

ArgumentNullException

continuationAction 参数为 null。

ArgumentOutOfRangeException

continuationOptions 参数为 TaskContinuationOptions 指定无效值。

注解

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

另请参阅

使用延续任务来链接任务

适用于

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

Source:: Future.cs

Source:: Future.cs

Source:: Future.cs

创建一个在目标 Task<TResult> 完成时执行的延续任务。

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task<TResult> ^, System::Object ^> ^ continuationAction, System::Object ^ state, System::Threading::CancellationToken cancellationToken);

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

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

override this.ContinueWith : Action<System.Threading.Tasks.Task<'Result>, obj> * obj * System.Threading.CancellationToken -> System.Threading.Tasks.Task

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

参数

continuationAction: Action<Task<TResult>,Object>

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

state: Object

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

cancellationToken: CancellationToken

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

Task

一个新的延续 Task。

例外

ArgumentNullException

continuationAction 参数为 null。

ObjectDisposedException

已释放提供的 CancellationToken。

注解

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

另请参阅

使用延续任务来链接任务

适用于

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

Source:: Future.cs

Source:: Future.cs

Source:: Future.cs

创建根据 continuationOptions 中指定的条件加以执行的延续任务。

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task<TResult> ^> ^ 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<TResult>> continuationAction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);

override this.ContinueWith : Action<System.Threading.Tasks.Task<'Result>> * System.Threading.CancellationToken * System.Threading.Tasks.TaskContinuationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task

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

参数

continuationAction: Action<Task<TResult>>

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

cancellationToken: CancellationToken

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

continuationOptions: TaskContinuationOptions

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

scheduler: TaskScheduler

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

Task

一个新的延续 Task。

例外

ObjectDisposedException

已释放了 Task<TResult>。

- 或 -

创建了 cancellationToken 的 CancellationTokenSource 已经被释放。

ArgumentNullException

continuationAction 参数为 null。

或

scheduler 参数为 null。

ArgumentOutOfRangeException

continuationOptions 参数为 TaskContinuationOptions 指定无效值。

注解

在当前任务完成之前，不会计划返回 Task 的执行。如果不满足通过 continuationOptions 参数指定的条件，则会取消延续任务，而不是计划任务。有关详细信息，请参阅使用延续任务链接任务。

另请参阅

适用于

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

Source:: Future.cs

Source:: Future.cs

Source:: Future.cs

创建根据 continuationOptions 中指定的条件加以执行的延续任务。

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

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

override this.ContinueWith : Action<System.Threading.Tasks.Task<'Result>> * System.Threading.Tasks.TaskContinuationOptions -> System.Threading.Tasks.Task

Public Function ContinueWith (continuationAction As Action(Of Task(Of TResult)), continuationOptions As TaskContinuationOptions) As Task

参数

continuationAction: Action<Task<TResult>>

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

continuationOptions: TaskContinuationOptions

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

Task

一个新的延续 Task。

例外

ObjectDisposedException

已释放了 Task<TResult>。

ArgumentNullException

continuationAction 参数为 null。

ArgumentOutOfRangeException

continuationOptions 参数为 TaskContinuationOptions 指定无效值。

注解

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

有关详细信息，请参阅使用延续任务链接任务。

另请参阅

适用于

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

Source:: Future.cs

Source:: Future.cs

Source:: Future.cs

创建一个在目标 Task<TResult> 完成时异步执行的可取消延续任务。

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

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

override this.ContinueWith : Action<System.Threading.Tasks.Task<'Result>> * System.Threading.CancellationToken -> System.Threading.Tasks.Task

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

参数

continuationAction: Action<Task<TResult>>

在 Task<TResult> 完成时要运行的操作。在运行时，委托作为一个参数传递给完成的任务。

cancellationToken: CancellationToken

传递给新的延续任务的取消标记。

Task

一个新的延续任务。

例外

ObjectDisposedException

已释放了 Task<TResult>。

- 或 -

创建了 cancellationToken 的 CancellationTokenSource 已经被释放。

ArgumentNullException

continuationAction 参数为 null。

示例

以下示例创建一个使用 Eratosthenes 的 Sieve 计算 1 与用户输入的值之间的质数的前一个任务。数组用于保存有关质数的信息。数组索引表示数字，元素的值指示该数字是复合的， (其值 true 是) 还是质 (其值 false) 。然后，此任务将传递给延续任务，该任务负责从整数数组中提取质数并显示它们。

取消令牌同时传递给前面的任务和延续任务。对象 System.Timers.Timer 用于定义 100 毫秒的超时值。如果事件触发， CancellationTokenSource.Cancel 则调用方法，并使用取消令牌请求取消任务。

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using Timers = System.Timers;

public class Example
{
   static CancellationTokenSource ts;
   
   public static void Main(string[] args)
   {
      int upperBound = args.Length >= 1 ? Int32.Parse(args[0]) : 200;
      ts = new CancellationTokenSource();
      CancellationToken token = ts.Token;
      Timers.Timer timer = new Timers.Timer(3000);
      timer.Elapsed += TimedOutEvent;
      timer.AutoReset = false;
      timer.Enabled = true;

      var t1 = Task.Run(() => { // True = composite.
                                // False = prime.
                                bool[] values = new bool[upperBound + 1];
                                for (int ctr = 2; ctr <= (int) Math.Sqrt(upperBound); ctr++) {
                                   if (values[ctr] == false) {
                                      for (int product = ctr * ctr; product <= upperBound;
                                                                    product = product + ctr)
                                         values[product] = true;
                                   }
                                   token.ThrowIfCancellationRequested();
                                }
                                return values; }, token);

      var t2 = t1.ContinueWith( (antecedent) => { // Create a list of prime numbers.
                                                  var  primes = new List<int>();
                                                  token.ThrowIfCancellationRequested();
                                                  bool[] numbers = antecedent.Result;
                                                  string output = String.Empty;

                                                  for (int ctr = 1; ctr <= numbers.GetUpperBound(0); ctr++)
                                                     if (numbers[ctr] == false)
                                                        primes.Add(ctr);

                                                  // Create the output string.
                                                  for (int ctr = 0; ctr < primes.Count; ctr++) {
                                                     token.ThrowIfCancellationRequested();
                                                     output += primes[ctr].ToString("N0");
                                                     if (ctr < primes.Count - 1)
                                                        output += ",  ";
                                                     if ((ctr + 1) % 8 == 0)
                                                        output += Environment.NewLine;
                                                  }
                                                  //Display the result.
                                                  Console.WriteLine("Prime numbers from 1 to {0}:\n",
                                                                    upperBound);
                                                  Console.WriteLine(output);
                                                }, token);
      try {
         t2.Wait();
      }
      catch (AggregateException ae) {
         foreach (var e in ae.InnerExceptions) {
            if (e.GetType() == typeof(TaskCanceledException))
               Console.WriteLine("The operation was cancelled.");
            else
               Console.WriteLine("ELSE: {0}: {1}", e.GetType().Name, e.Message);
         }
      }
      finally {
         ts.Dispose();
      }
   }

   private static void TimedOutEvent(Object source, Timers.ElapsedEventArgs e)
   {
      ts.Cancel();
   }
}
// If cancellation is not requested, the example displays output like the following:
//       Prime numbers from 1 to 400:
//
//       1,  2,  3,  5,  7,  11,  13,  17,
//       19,  23,  29,  31,  37,  41,  43,  47,
//       53,  59,  61,  67,  71,  73,  79,  83,
//       89,  97,  101,  103,  107,  109,  113,  127,
//       131,  137,  139,  149,  151,  157,  163,  167,
//       173,  179,  181,  191,  193,  197,  199,  211,
//       223,  227,  229,  233,  239,  241,  251,  257,
//       263,  269,  271,  277,  281,  283,  293,  307,
//       311,  313,  317,  331,  337,  347,  349,  353,
//       359,  367,  373,  379,  383,  389,  397,  401
// If cancellation is requested, the example displays output like the following:
//       The operation was cancelled.

Imports System.Collections.Generic
Imports System.Threading
Imports System.Threading.Tasks
Imports Timers = System.Timers

Module Example
   Dim ts As CancellationTokenSource

   Public Sub Main(args() As String)
      Dim upperBound As Integer = If(args.Length >= 1, CInt(args(0)), 200)
      ts = New CancellationTokenSource()
      Dim token As CancellationToken = ts.Token
      Dim timer As New Timers.Timer(100)
      AddHandler timer.Elapsed, AddressOf TimedOutEvent
      timer.AutoReset = False
      timer.Enabled = True

      Dim t1 = Task.Run(Function()
                          ' True = composite.
                          ' False = prime.
                          Dim values(upperBound) As Boolean
                          For ctr = 2 To CInt(Math.Sqrt(upperBound))
                             If values(ctr) = False Then
                                For product = ctr * ctr To upperBound Step ctr
                                   values(product) = True
                                Next
                             End If
                             token.ThrowIfCancellationRequested()
                          Next
                          Return values
                       End Function, token)

      Dim t2 = t1.ContinueWith(Sub(antecedent)
                                  ' Create a list of prime numbers.
                                  Dim primes As New List(Of Integer)()
                                  token.ThrowIfCancellationRequested()
                                  Dim numbers As Boolean() = antecedent.Result
                                  Dim output As String = String.Empty
                                  
                                  For ctr As Integer = 1 To numbers.GetUpperBound(0)
                                     If numbers(ctr) = False Then primes.Add(ctr)
                                  Next

                                  ' Create the output string.
                                  For ctr As Integer = 0 To primes.Count - 1
                                     token.ThrowIfCancellationRequested()
                                     output += primes(ctr).ToString("N0")
                                     If ctr < primes.Count - 1 Then output += ",  "
                                     If (ctr + 1) Mod 8 = 0 Then output += vbCrLf
                                  Next
                                  'Display the result.
                                  Console.WriteLine("Prime numbers from 1 to {0}:{1}",
                                                    upperBound, vbCrLf)
                                  Console.WriteLine(output)
                               End Sub, token)
      Try
         t2.Wait()
      Catch ae As AggregateException
         For Each e In ae.InnerExceptions
            If e.GetType Is GetType(TaskCanceledException) Then
               Console.WriteLine("The operation was cancelled.")
            Else
               Console.WriteLine("{0}: {1}", e.GetType().Name, e.Message)
            End If
         Next
      Finally
         ts.Dispose()
      End Try
   End Sub
   
   Private Sub TimedOutEvent(source As Object, e As Timers.ElapsedEventArgs)
      ts.Cancel()
   End Sub
End Module
' If cancellation is not requested, the example displays output like the following:
'       Prime numbers from 1 to 400:
'
'       1,  2,  3,  5,  7,  11,  13,  17,
'       19,  23,  29,  31,  37,  41,  43,  47,
'       53,  59,  61,  67,  71,  73,  79,  83,
'       89,  97,  101,  103,  107,  109,  113,  127,
'       131,  137,  139,  149,  151,  157,  163,  167,
'       173,  179,  181,  191,  193,  197,  199,  211,
'       223,  227,  229,  233,  239,  241,  251,  257,
'       263,  269,  271,  277,  281,  283,  293,  307,
'       311,  313,  317,  331,  337,  347,  349,  353,
'       359,  367,  373,  379,  383,  389,  397,  401
' If cancellation is requested, the example displays output like the following:
'       The operation was cancelled.

通常，提供大约 100，000 的值会导致超时间隔过期并 Timer.Elapsed 触发事件，并设置取消请求。

注解

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

另请参阅

适用于

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

Source:: Future.cs

Source:: Future.cs

Source:: Future.cs

创建一个传递有状态信息并在目标 Task<TResult> 完成时执行的延续。

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task<TResult> ^, System::Object ^> ^ continuationAction, System::Object ^ state);

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

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

override this.ContinueWith : Action<System.Threading.Tasks.Task<'Result>, obj> * obj -> System.Threading.Tasks.Task

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

参数

continuationAction: Action<Task<TResult>,Object>

在 Task<TResult> 完成时要运行的操作。运行时，委托作为参数传递已完成的任务和调用方提供的状态对象。

state: Object

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

Task

一个新的延续 Task。

例外

ArgumentNullException

continuationAction 参数为 null。

示例

以下示例创建一个任务，该任务传递了一个介于 2 和 20 之间的整数，并返回一个数组，其中包含该数字的前¹⁰ 个指数 (n 1 到 n¹⁰) 。然后，延续任务负责显示指数。它同时传递前身和原始数字，其指数为前者生成的指数。

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

public class Example
{
   public static void Main()
   {
      var cts = new CancellationTokenSource();
      var token = cts.Token;

      // Get an integer to generate a list of its exponents.
      var rnd = new Random();
      var number = rnd.Next(2, 21);
      
      var t = Task.Factory.StartNew( (value) => { int n = (int) value;
                                                  long[] values = new long[10];
                                                  for (int ctr = 1; ctr <= 10; ctr++)
                                                     values[ctr - 1] = (long) Math.Pow(n, ctr);
                                                     
                                                  return values;
                                                }, number);
      var continuation = t.ContinueWith( (antecedent, value) => { Console.WriteLine("Exponents of {0}:", value);
                                                                  for (int ctr = 0; ctr <= 9; ctr++)
                                                                     Console.WriteLine("   {0} {1} {2} = {3:N0}",
                                                                                       value, "\u02C6", ctr + 1,
                                                                                       antecedent.Result[ctr]);
                                                                  Console.WriteLine();
                                                                }, number);
      continuation.Wait();
      cts.Dispose();
   }
}
// The example displays output like the following:
//       Exponents of 2:
//          2 ^ 1 = 2
//          2 ^ 2 = 4
//          2 ^ 3 = 8
//          2 ^ 4 = 16
//          2 ^ 5 = 32
//          2 ^ 6 = 64
//          2 ^ 7 = 128
//          2 ^ 8 = 256
//          2 ^ 9 = 512
//          2 ^ 10 = 1,024

Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim cts As New CancellationTokenSource()
      Dim token As CancellationToken = cts.Token

      ' Get an integer to generate a list of its exponents.
      Dim rnd As New Random()
      Dim number As Integer = rnd.Next(2, 21)

      Dim t = Task.Factory.StartNew( Function(value)
                                        Dim n As Integer = CInt(value)
                                        Dim values(9) As Long
                                        For ctr As Integer = 1 To 10
                                           values(ctr - 1) = CLng(Math.Pow(n, ctr))
                                        Next
                                        return values
                                     End Function, number)
      Dim continuation = t.ContinueWith( Sub(antecedent, value)
                                            Console.WriteLine("Exponents of {0}:", value)
                                            For ctr As Integer = 0 To 9
                                               Console.WriteLine("   {0} {1} {2} = {3:N0}",
                                                                 value, ChrW(&h02C6), ctr + 1,
                                                                 antecedent.Result(ctr))
                                            Next
                                            Console.WriteLine()
                                         End Sub, number)
      continuation.Wait()

      cts.Dispose()
   End Sub
End Module
' The example displays output like the following:
'       Exponents of 2:
'          2 ^ 1 = 2
'          2 ^ 2 = 4
'          2 ^ 3 = 8
'          2 ^ 4 = 16
'          2 ^ 5 = 32
'          2 ^ 6 = 64
'          2 ^ 7 = 128
'          2 ^ 8 = 256
'          2 ^ 9 = 512
'          2 ^ 10 = 1,024

注解

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

另请参阅

使用延续任务来链接任务

适用于

ContinueWith(Action<Task<TResult>>)

Source:: Future.cs

Source:: Future.cs

Source:: Future.cs

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

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task<TResult> ^> ^ continuationAction);

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

override this.ContinueWith : Action<System.Threading.Tasks.Task<'Result>> -> System.Threading.Tasks.Task

Public Function ContinueWith (continuationAction As Action(Of Task(Of TResult))) As Task

参数

continuationAction: Action<Task<TResult>>

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

Task

一个新的延续任务。

例外

ObjectDisposedException

已释放了 Task<TResult>。

ArgumentNullException

continuationAction 参数为 null。

示例

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main(string[] args)
   {
      int upperBound = args.Length >= 1 ? Int32.Parse(args[0]) : 200;

      var t1 = Task.Run(() => { // True = composite.
                                // False = prime.
                                bool[] values = new bool[upperBound + 1];
                                for (int ctr = 2; ctr <= (int) Math.Sqrt(upperBound); ctr++) {
                                   if (values[ctr] == false) {
                                      for (int product = ctr * ctr; product <= upperBound;
                                                                    product = product + ctr)
                                         values[product] = true;
                                   }
                                }
                                return values; });
      var t2 = t1.ContinueWith( (antecedent) => { // Create a list of prime numbers.
                                                  var  primes = new List<int>();
                                                  bool[] numbers = antecedent.Result;
                                                  string output = String.Empty;

                                                  for (int ctr = 1; ctr <= numbers.GetUpperBound(0); ctr++)
                                                     if (numbers[ctr] == false)
                                                        primes.Add(ctr);

                                                  // Create the output string.
                                                  for (int ctr = 0; ctr < primes.Count; ctr++) {
                                                     output += primes[ctr].ToString("N0");
                                                     if (ctr < primes.Count - 1)
                                                        output += ",  ";
                                                     if ((ctr + 1) % 8 == 0)
                                                        output += Environment.NewLine;
                                                  }
                                                  //Display the result.
                                                  Console.WriteLine("Prime numbers from 1 to {0}:\n",
                                                                    upperBound);
                                                  Console.WriteLine(output);
                                                });
      try {
         t2.Wait();
      }
      catch (AggregateException ae) {
         foreach (var e in ae.InnerExceptions)
            Console.WriteLine("{0}: {1}", e.GetType().Name, e.Message);
      }
   }
}
// The example displays output like the following:
//       Prime numbers from 1 to 400:
//
//       1,  2,  3,  5,  7,  11,  13,  17,
//       19,  23,  29,  31,  37,  41,  43,  47,
//       53,  59,  61,  67,  71,  73,  79,  83,
//       89,  97,  101,  103,  107,  109,  113,  127,
//       131,  137,  139,  149,  151,  157,  163,  167,
//       173,  179,  181,  191,  193,  197,  199,  211,
//       223,  227,  229,  233,  239,  241,  251,  257,
//       263,  269,  271,  277,  281,  283,  293,  307,
//       311,  313,  317,  331,  337,  347,  349,  353,
//       359,  367,  373,  379,  383,  389,  397,  401

Imports System.Collections.Generic
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main(args() As String)
      Dim upperBound As Integer = If(args.Length >= 1, CInt(args(0)), 200)

      Dim t1 = Task.Run(Function()
                          ' True = composite.
                          ' False = prime.
                          Dim values(upperBound) As Boolean
                          For ctr = 2 To CInt(Math.Sqrt(upperBound))
                             If values(ctr) = False Then
                                For product = ctr * ctr To upperBound Step ctr
                                   values(product) = True
                                Next
                             End If
                          Next
                          Return values
                       End Function)

      Dim t2 = t1.ContinueWith(Sub(antecedent)
                                  ' Create a list of prime numbers.
                                  Dim primes As New List(Of Integer)()
                                  Dim numbers As Boolean() = antecedent.Result
                                  Dim output As String = String.Empty
                                  
                                  For ctr As Integer = 1 To numbers.GetUpperBound(0)
                                     If numbers(ctr) = False Then primes.Add(ctr)
                                  Next

                                  ' Create the output string.
                                  For ctr As Integer = 0 To primes.Count - 1
                                     output += primes(ctr).ToString("N0")
                                     If ctr < primes.Count - 1 Then output += ",  "
                                     If (ctr + 1) Mod 8 = 0 Then output += vbCrLf
                                  Next
                                  'Display the result.
                                  Console.WriteLine("Prime numbers from 1 to {0}:{1}",
                                                    upperBound, vbCrLf)
                                  Console.WriteLine(output)
                               End Sub)
      Try
         t2.Wait()
      Catch ae As AggregateException
         For Each e In ae.InnerExceptions
            Console.WriteLine("{0}: {1}", e.GetType().Name, e.Message)
         Next
      End Try
   End Sub
End Module
' The example displays output like the following:
'       Prime numbers from 1 to 400:
'
'       1,  2,  3,  5,  7,  11,  13,  17,
'       19,  23,  29,  31,  37,  41,  43,  47,
'       53,  59,  61,  67,  71,  73,  79,  83,
'       89,  97,  101,  103,  107,  109,  113,  127,
'       131,  137,  139,  149,  151,  157,  163,  167,
'       173,  179,  181,  191,  193,  197,  199,  211,
'       223,  227,  229,  233,  239,  241,  251,  257,
'       263,  269,  271,  277,  281,  283,  293,  307,
'       311,  313,  317,  331,  337,  347,  349,  353,
'       359,  367,  373,  379,  383,  389,  397,  401
' If cancellation is requested, the example displays output like the following:
'       The operation was cancelled.

注解

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

另请参阅

适用于

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

Source:: Future.cs

Source:: Future.cs

Source:: Future.cs

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

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

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

override this.ContinueWith : Action<System.Threading.Tasks.Task<'Result>> * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task

Public Function ContinueWith (continuationAction As Action(Of Task(Of TResult)), scheduler As TaskScheduler) As Task

参数

continuationAction: Action<Task<TResult>>

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

scheduler: TaskScheduler

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

Task

一个新的延续 Task。

例外

ObjectDisposedException

已释放了 Task<TResult>。

ArgumentNullException

continuationAction 参数为 null。

或

scheduler 参数为 null。

注解

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

另请参阅

适用于

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

Source:: Future.cs

Source:: Future.cs

Source:: Future.cs

创建一个在目标 Task<TResult> 完成时执行的延续任务。

public:
generic <typename TNewResult>
 System::Threading::Tasks::Task<TNewResult> ^ ContinueWith(Func<System::Threading::Tasks::Task<TResult> ^, System::Object ^, TNewResult> ^ continuationFunction, System::Object ^ state, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskContinuationOptions continuationOptions, System::Threading::Tasks::TaskScheduler ^ scheduler);

public System.Threading.Tasks.Task<TNewResult> ContinueWith<TNewResult> (Func<System.Threading.Tasks.Task<TResult>,object,TNewResult> continuationFunction, object state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);

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

override this.ContinueWith : Func<System.Threading.Tasks.Task<'Result>, obj, 'NewResult> * obj * System.Threading.CancellationToken * System.Threading.Tasks.TaskContinuationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task<'NewResult>

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

类型参数

TNewResult

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

参数

continuationFunction: Func<Task<TResult>,Object,TNewResult>

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

state: Object

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

cancellationToken: CancellationToken

将指派给新任务的 CancellationToken。

continuationOptions: TaskContinuationOptions

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

scheduler: TaskScheduler

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

Task<TNewResult>

一个新的延续 Task<TResult>。

例外

ArgumentNullException

scheduler 参数为 null。

ArgumentOutOfRangeException

continuationOptions 参数为 TaskContinuationOptions 指定无效值。

ObjectDisposedException

已释放提供的 CancellationToken。

注解

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

continuationFunction执行时，应返回 Task<TResult>。此任务的完成状态将传输到从 Task<TResult>.ContinueWith 调用返回的任务。

另请参阅

使用延续任务来链接任务

适用于

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

Source:: Future.cs

Source:: Future.cs

Source:: Future.cs

创建根据 continuationOptions 中指定的条件加以执行的延续任务。

public:
generic <typename TNewResult>
 System::Threading::Tasks::Task<TNewResult> ^ ContinueWith(Func<System::Threading::Tasks::Task<TResult> ^, TNewResult> ^ continuationFunction, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskContinuationOptions continuationOptions, System::Threading::Tasks::TaskScheduler ^ scheduler);

public System.Threading.Tasks.Task<TNewResult> ContinueWith<TNewResult> (Func<System.Threading.Tasks.Task<TResult>,TNewResult> continuationFunction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);

override this.ContinueWith : Func<System.Threading.Tasks.Task<'Result>, 'NewResult> * System.Threading.CancellationToken * System.Threading.Tasks.TaskContinuationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task<'NewResult>

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

类型参数

TNewResult

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

参数

continuationFunction: Func<Task<TResult>,TNewResult>

根据 continuationOptions 中指定的条件运行函数。

在运行时，委托将作为一个参数传递给此完成的任务。

cancellationToken: CancellationToken

将指派给新任务的 CancellationToken。

continuationOptions: TaskContinuationOptions

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

scheduler: TaskScheduler

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

Task<TNewResult>

一个新的延续 Task<TResult>。

例外

ObjectDisposedException

已释放了 Task<TResult>。

- 或 -

创建了 cancellationToken 的 CancellationTokenSource 已经被释放。

ArgumentNullException

continuationFunction 参数为 null。

或

scheduler 参数为 null。

ArgumentOutOfRangeException

continuationOptions 参数为 TaskContinuationOptions 指定无效值。

注解

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

continuationFunction执行时，应返回 Task<TResult>。

另请参阅

适用于

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

Source:: Future.cs

Source:: Future.cs

Source:: Future.cs

创建一个在目标 Task<TResult> 完成时执行的延续任务。

public:
generic <typename TNewResult>
 System::Threading::Tasks::Task<TNewResult> ^ ContinueWith(Func<System::Threading::Tasks::Task<TResult> ^, System::Object ^, TNewResult> ^ continuationFunction, System::Object ^ state, System::Threading::Tasks::TaskScheduler ^ scheduler);

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

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

override this.ContinueWith : Func<System.Threading.Tasks.Task<'Result>, obj, 'NewResult> * obj * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task<'NewResult>

Public Function ContinueWith(Of TNewResult) (continuationFunction As Func(Of Task(Of TResult), Object, TNewResult), state As Object, scheduler As TaskScheduler) As Task(Of TNewResult)

类型参数

TNewResult

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

参数

continuationFunction: Func<Task<TResult>,Object,TNewResult>

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

state: Object

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

scheduler: TaskScheduler

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

Task<TNewResult>

一个新的延续 Task<TResult>。

例外

ArgumentNullException

scheduler 参数为 null。

注解

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

另请参阅

使用延续任务来链接任务

适用于

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

Source:: Future.cs

Source:: Future.cs

Source:: Future.cs

创建一个在目标 Task<TResult> 完成时执行的延续任务。

public:
generic <typename TNewResult>
 System::Threading::Tasks::Task<TNewResult> ^ ContinueWith(Func<System::Threading::Tasks::Task<TResult> ^, System::Object ^, TNewResult> ^ continuationFunction, System::Object ^ state, System::Threading::CancellationToken cancellationToken);

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

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

override this.ContinueWith : Func<System.Threading.Tasks.Task<'Result>, obj, 'NewResult> * obj * System.Threading.CancellationToken -> System.Threading.Tasks.Task<'NewResult>

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

类型参数

TNewResult

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

参数

continuationFunction: Func<Task<TResult>,Object,TNewResult>

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

state: Object

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

cancellationToken: CancellationToken

将指派给新任务的 CancellationToken。

Task<TNewResult>

一个新的延续 Task<TResult>。

例外

ArgumentNullException

continuationFunction 参数为 null。

ObjectDisposedException

已释放提供的 CancellationToken。

注解

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

另请参阅

使用延续任务来链接任务

适用于

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

Source:: Future.cs

Source:: Future.cs

Source:: Future.cs

创建一个在目标 Task<TResult> 完成时执行的延续任务。

public:
generic <typename TNewResult>
 System::Threading::Tasks::Task<TNewResult> ^ ContinueWith(Func<System::Threading::Tasks::Task<TResult> ^, System::Object ^, TNewResult> ^ continuationFunction, System::Object ^ state, System::Threading::Tasks::TaskContinuationOptions continuationOptions);

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

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

override this.ContinueWith : Func<System.Threading.Tasks.Task<'Result>, obj, 'NewResult> * obj * System.Threading.Tasks.TaskContinuationOptions -> System.Threading.Tasks.Task<'NewResult>

Public Function ContinueWith(Of TNewResult) (continuationFunction As Func(Of Task(Of TResult), Object, TNewResult), state As Object, continuationOptions As TaskContinuationOptions) As Task(Of TNewResult)

类型参数

TNewResult

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

参数

continuationFunction: Func<Task<TResult>,Object,TNewResult>

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

state: Object

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

continuationOptions: TaskContinuationOptions

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

Task<TNewResult>

一个新的延续 Task<TResult>。

例外

ArgumentNullException

continuationFunction 参数为 null。

ArgumentOutOfRangeException

continuationOptions 参数为 TaskContinuationOptions 指定无效值。

注解

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

continuationFunction执行时，应返回 Task<TResult>。此任务的完成状态将转移到从 ContinueWith 调用返回的任务。

另请参阅

使用延续任务来链接任务

适用于

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

Source:: Future.cs

Source:: Future.cs

Source:: Future.cs

创建根据 continuationOptions 中指定的条件加以执行的延续任务。

public:
generic <typename TNewResult>
 System::Threading::Tasks::Task<TNewResult> ^ ContinueWith(Func<System::Threading::Tasks::Task<TResult> ^, TNewResult> ^ continuationFunction, System::Threading::Tasks::TaskContinuationOptions continuationOptions);

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

override this.ContinueWith : Func<System.Threading.Tasks.Task<'Result>, 'NewResult> * System.Threading.Tasks.TaskContinuationOptions -> System.Threading.Tasks.Task<'NewResult>

Public Function ContinueWith(Of TNewResult) (continuationFunction As Func(Of Task(Of TResult), TNewResult), continuationOptions As TaskContinuationOptions) As Task(Of TNewResult)

类型参数

TNewResult

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

参数

continuationFunction: Func<Task<TResult>,TNewResult>

根据 continuationOptions 中指定的条件运行函数。

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

continuationOptions: TaskContinuationOptions

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

Task<TNewResult>

一个新的延续 Task<TResult>。

例外

ObjectDisposedException

已释放了 Task<TResult>。

ArgumentNullException

continuationFunction 参数为 null。

ArgumentOutOfRangeException

continuationOptions 参数为 TaskContinuationOptions 指定无效值。

注解

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

continuationFunction执行时，应返回 Task<TResult>。

另请参阅

适用于

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

Source:: Future.cs

Source:: Future.cs

Source:: Future.cs

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

public:
generic <typename TNewResult>
 System::Threading::Tasks::Task<TNewResult> ^ ContinueWith(Func<System::Threading::Tasks::Task<TResult> ^, TNewResult> ^ continuationFunction, System::Threading::CancellationToken cancellationToken);

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

override this.ContinueWith : Func<System.Threading.Tasks.Task<'Result>, 'NewResult> * System.Threading.CancellationToken -> System.Threading.Tasks.Task<'NewResult>

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

类型参数

TNewResult

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

参数

continuationFunction: Func<Task<TResult>,TNewResult>

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

cancellationToken: CancellationToken

将指派给新任务的 CancellationToken。

Task<TNewResult>

一个新的延续 Task<TResult>。

例外

ObjectDisposedException

已释放了 Task<TResult>。

- 或 -

创建了 cancellationToken 的 CancellationTokenSource 已经被释放。

ArgumentNullException

continuationFunction 参数为 null。

注解

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

另请参阅

适用于

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

Source:: Future.cs

Source:: Future.cs

Source:: Future.cs

创建一个在目标 Task<TResult> 完成时执行的延续任务。

public:
generic <typename TNewResult>
 System::Threading::Tasks::Task<TNewResult> ^ ContinueWith(Func<System::Threading::Tasks::Task<TResult> ^, System::Object ^, TNewResult> ^ continuationFunction, System::Object ^ state);

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

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

override this.ContinueWith : Func<System.Threading.Tasks.Task<'Result>, obj, 'NewResult> * obj -> System.Threading.Tasks.Task<'NewResult>

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

类型参数

TNewResult

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

参数

continuationFunction: Func<Task<TResult>,Object,TNewResult>

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

state: Object

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

Task<TNewResult>

一个新的延续 Task<TResult>。

例外

ArgumentNullException

continuationFunction 参数为 null。

示例

以下示例创建一个延续任务链。每个任务为方法的状态参数ContinueWith(Action<Task,Object>, Object)提供当前时间（一个 DateTime 对象）。每个 DateTime 值表示创建继续任务的时间。每个任务将生成一个表示任务完成时间的第二 DateTime 个值作为其结果。所有任务完成后，该示例显示每个延续任务开始和完成的日期和时间。

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

// Demonstrates how to associate state with task continuations.
class ContinuationState
{
   // Simluates a lengthy operation and returns the time at which
   // the operation completed.
   public static DateTime DoWork()
   {
      // Simulate work by suspending the current thread
      // for two seconds.
      Thread.Sleep(2000);

      // Return the current time.
      return DateTime.Now;
   }

   static void Main(string[] args)
   {
      // Start a root task that performs work.
      Task<DateTime> t = Task<DateTime>.Run(delegate { return DoWork(); });

      // Create a chain of continuation tasks, where each task is
      // followed by another task that performs work.
      List<Task<DateTime>> continuations = new List<Task<DateTime>>();
      for (int i = 0; i < 5; i++)
      {
         // Provide the current time as the state of the continuation.
         t = t.ContinueWith(delegate { return DoWork(); }, DateTime.Now);
         continuations.Add(t);
      }

      // Wait for the last task in the chain to complete.
      t.Wait();

      // Print the creation time of each continuation (the state object)
      // and the completion time (the result of that task) to the console.
      foreach (var continuation in continuations)
      {
         DateTime start = (DateTime)continuation.AsyncState;
         DateTime end = continuation.Result;

         Console.WriteLine("Task was created at {0} and finished at {1}.",
            start.TimeOfDay, end.TimeOfDay);
      }
   }
}

/* Sample output:
Task was created at 10:56:21.1561762 and finished at 10:56:25.1672062.
Task was created at 10:56:21.1610677 and finished at 10:56:27.1707646.
Task was created at 10:56:21.1610677 and finished at 10:56:29.1743230.
Task was created at 10:56:21.1610677 and finished at 10:56:31.1779883.
Task was created at 10:56:21.1610677 and finished at 10:56:33.1837083.
*/

Imports System.Collections.Generic
Imports System.Threading
Imports System.Threading.Tasks

' Demonstrates how to associate state with task continuations.
Public Module ContinuationState
   ' Simluates a lengthy operation and returns the time at which
   ' the operation completed.
   Public Function DoWork() As Date
      ' Simulate work by suspending the current thread 
      ' for two seconds.
      Thread.Sleep(2000)

      ' Return the current time.
      Return Date.Now
   End Function

   Public Sub Main()
      ' Start a root task that performs work.
      Dim t As Task(Of Date) = Task(Of Date).Run(Function() DoWork())

      ' Create a chain of continuation tasks, where each task is
      ' followed by another task that performs work.
      Dim continuations As New List(Of Task(Of DateTime))()
      For i As Integer = 0 To 4
         ' Provide the current time as the state of the continuation.
         t = t.ContinueWith(Function(antecedent, state) DoWork(), DateTime.Now)
         continuations.Add(t)
      Next

      ' Wait for the last task in the chain to complete.
      t.Wait()

      ' Display the creation time of each continuation (the state object)
      ' and the completion time (the result of that task) to the console.
      For Each continuation In continuations
         Dim start As DateTime = CDate(continuation.AsyncState)
         Dim [end] As DateTime = continuation.Result

         Console.WriteLine("Task was created at {0} and finished at {1}.",
            start.TimeOfDay, [end].TimeOfDay)
      Next
   End Sub
End Module
' The example displays output like the following:
'       Task was created at 10:56:21.1561762 and finished at 10:56:25.1672062.
'       Task was created at 10:56:21.1610677 and finished at 10:56:27.1707646.
'       Task was created at 10:56:21.1610677 and finished at 10:56:29.1743230.
'       Task was created at 10:56:21.1610677 and finished at 10:56:31.1779883.
'       Task was created at 10:56:21.1610677 and finished at 10:56:33.1837083.

注解

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

另请参阅

使用延续任务来链接任务

适用于

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

Source:: Future.cs

Source:: Future.cs

Source:: Future.cs

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

public:
generic <typename TNewResult>
 System::Threading::Tasks::Task<TNewResult> ^ ContinueWith(Func<System::Threading::Tasks::Task<TResult> ^, TNewResult> ^ continuationFunction);

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

override this.ContinueWith : Func<System.Threading.Tasks.Task<'Result>, 'NewResult> -> System.Threading.Tasks.Task<'NewResult>

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

类型参数

TNewResult

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

参数

continuationFunction: Func<Task<TResult>,TNewResult>

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

Task<TNewResult>

一个新的延续 Task<TResult>。

例外

ObjectDisposedException

已释放了 Task<TResult>。

ArgumentNullException

continuationFunction 参数为 null。

注解

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

另请参阅

适用于

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

Source:: Future.cs

Source:: Future.cs

Source:: Future.cs

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

public:
generic <typename TNewResult>
 System::Threading::Tasks::Task<TNewResult> ^ ContinueWith(Func<System::Threading::Tasks::Task<TResult> ^, TNewResult> ^ continuationFunction, System::Threading::Tasks::TaskScheduler ^ scheduler);

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

override this.ContinueWith : Func<System.Threading.Tasks.Task<'Result>, 'NewResult> * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task<'NewResult>

Public Function ContinueWith(Of TNewResult) (continuationFunction As Func(Of Task(Of TResult), TNewResult), scheduler As TaskScheduler) As Task(Of TNewResult)

类型参数

TNewResult

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

参数

continuationFunction: Func<Task<TResult>,TNewResult>

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

scheduler: TaskScheduler

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

Task<TNewResult>

一个新的延续 Task<TResult>。

例外

ObjectDisposedException

已释放了 Task<TResult>。

ArgumentNullException

continuationFunction 参数为 null。

或

scheduler 参数为 null。

注解

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

另请参阅

适用于