Task<TResult>.ContinueWith 方法

定义

创建当另一任务完成时可以执行的延续任务。Creates a continuation task that executes when another task completes.

重载

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

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

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

创建根据 continuationOptions 中指定的条件加以执行的延续任务。Creates a continuation that executes according the condition specified in continuationOptions.

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

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

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

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

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

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

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

创建根据 continuationOptions 中指定的条件加以执行的延续任务。Creates a continuation that executes according the condition specified in continuationOptions.

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

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

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

创建一个传递有状态信息并在目标 Task<TResult> 完成时执行的延续。Creates a continuation that is passed state information and that executes when the target Task<TResult> completes.

ContinueWith(Action<Task<TResult>>)

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

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

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

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

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

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

创建根据 continuationOptions 中指定的条件加以执行的延续任务。Creates a continuation that executes according the condition specified in continuationOptions.

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

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

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

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

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

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

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

创建根据 continuationOptions 中指定的条件加以执行的延续任务。Creates a continuation that executes according the condition specified in continuationOptions.

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

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

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

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

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

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

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

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

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

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

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

state
Object

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

cancellationToken
CancellationToken

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

continuationOptions
TaskContinuationOptions

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

scheduler
TaskScheduler

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

返回

Task

一个新的延续 TaskA new continuation Task.

例外

scheduler 参数为 nullThe scheduler argument is null.

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

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

注解

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

另请参阅

适用于

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

创建根据 continuationOptions 中指定的条件加以执行的延续任务。Creates a continuation that executes according the condition specified in 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 中指定的条件运行的操作。An action to run according the condition specified in continuationOptions. 在运行时,委托将作为一个自变量传递给完成的任务。When run, the delegate will be passed the completed task as an argument.

cancellationToken
CancellationToken

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

continuationOptions
TaskContinuationOptions

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

scheduler
TaskScheduler

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

返回

Task

一个新的延续 TaskA new continuation Task.

例外

已释放了 Task<TResult>The Task<TResult> has been disposed.

- 或 --or- 创建了 cancellationTokenCancellationTokenSource 已经被释放。The CancellationTokenSource that created cancellationToken has already been disposed.

continuationAction 参数为 nullThe continuationAction argument is null.

- 或 --or- scheduler 参数为 nullThe scheduler argument is null.

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

注解

Task直到当前任务完成后,才会安排返回的执行。The returned Task will not be scheduled for execution until the current task has completed. 如果未满足通过参数指定的条件 continuationOptions ,则将取消延续任务,而不是计划。If the criteria specified through the continuationOptions parameter are not met, the continuation task will be canceled instead of scheduled. 有关详细信息,请参阅使用延续任务链接任务For more information, see Chaining Tasks by Using Continuation Tasks.

另请参阅

适用于

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

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

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

state
Object

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

scheduler
TaskScheduler

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

返回

Task

一个新的延续 TaskA new continuation Task.

例外

scheduler 参数为 nullThe scheduler argument is null.

注解

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

另请参阅

适用于

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

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

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

state
Object

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

cancellationToken
CancellationToken

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

返回

Task

一个新的延续 TaskA new continuation Task.

例外

continuationAction 参数为 nullThe continuationAction argument is null.

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

注解

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

另请参阅

适用于

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

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

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

state
Object

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

continuationOptions
TaskContinuationOptions

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

返回

Task

一个新的延续 TaskA new continuation Task.

例外

continuationAction 参数为 nullThe continuationAction argument is null.

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

注解

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

另请参阅

适用于

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

创建根据 continuationOptions 中指定的条件加以执行的延续任务。Creates a continuation that executes according the condition specified in 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 中指定的条件的操作。An action to according the condition specified in continuationOptions. 在运行时,委托将作为一个自变量传递给完成的任务。When run, the delegate will be passed the completed task as an argument.

continuationOptions
TaskContinuationOptions

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

返回

Task

一个新的延续 TaskA new continuation Task.

例外

已释放了 Task<TResult>The Task<TResult> has been disposed.

continuationAction 参数为 nullThe continuationAction argument is null.

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

注解

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

有关详细信息,请参阅使用延续任务链接任务For more information, see Chaining Tasks by Using Continuation Tasks.

另请参阅

适用于

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

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

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> 完成时要运行的操作。An action to run when the Task<TResult> completes. 在运行时,委托作为一个参数传递给完成的任务。When run, the delegate is passed the completed task as an argument.

cancellationToken
CancellationToken

传递给新的延续任务的取消标记。The cancellation token that is passed to the new continuation task.

返回

Task

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

例外

已释放了 Task<TResult>The Task<TResult> has been disposed.

- 或 --or- 创建了 cancellationTokenCancellationTokenSource 已经被释放。The CancellationTokenSource that created cancellationToken has been disposed.

continuationAction 参数为 nullThe continuationAction argument is null.

示例

下面的示例创建一个前面的任务,该任务使用尼斯筛法的埃拉托色计算1与用户输入的值之间的质数。The following example creates an antecedent task that uses the Sieve of Eratosthenes to calculate the prime numbers between 1 and a value entered by the user. 数组用于保存有关质数的信息。An array is used to hold information about the prime numbers. 数组索引表示该数字,并且该元素的值指示该数字是复合的 (其值是 true) 还是质数 (其值 false) 。The array index represents the number, and the element's value indicates whether that number is composite (its value is true) or prime (its value is false). 然后,将此任务传递到延续任务,该任务负责从整数数组中提取质数并显示它们。This task is then passed to a continuation task, which is responsible for extracting the prime numbers from the integer array and displaying them.

取消标记将同时传递到前面的任务和延续任务。A cancellation token is passed to both the antecedent and the continuation task. System.Timers.Timer对象用于定义的超时值为100毫秒。A System.Timers.Timer object is used to define a timeout value of 100 milliseconds. 如果事件激发,将 CancellationTokenSource.Cancel 调用方法,并且取消标记用于请求取消任务。If the event fires, the CancellationTokenSource.Cancel method is called, and the cancellation token is used to request cancellation of the tasks.

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.

通常,提供约100000的值会导致超时间隔过期,并 Timer.Elapsed 引发事件以及要设置的取消请求。Typically, supplying a value of about 100,000 causes the timeout interval to expire and the Timer.Elapsed event to fire, and the cancellation request to be set.

注解

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

另请参阅

适用于

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

创建一个传递有状态信息并在目标 Task<TResult> 完成时执行的延续。Creates a continuation that is passed state information and that executes when the target Task<TResult> completes.

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

state
Object

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

返回

Task

一个新的延续 TaskA new continuation Task.

例外

continuationAction 参数为 nullThe continuationAction argument is null.

示例

下面的示例创建一个任务,该任务被传递一个介于2和20之间的整数,并返回一个数组,其中包含前10个指数 (从 n1 到 n10) 该数字。The following example creates a task that is passed an integer between 2 and 20 and returns an array that contains the first ten exponents (from n1 to n10) of that number. 然后,延续任务负责显示指数。A continuation task is then responsible for displaying the exponents. 它同时传递前面的任务和前面的任务生成的初始数字。It is passed both the antecedent and the original number whose exponents the antecedent generates.

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 将不会计划执行,直到当前任务已完成,该任务是否已完成,因为该任务已成功完成、是否由于未经处理的异常而发生故障,或由于被取消而发生错误。The returned Task will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

另请参阅

适用于

ContinueWith(Action<Task<TResult>>)

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

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

返回

Task

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

例外

已释放了 Task<TResult>The Task<TResult> has been disposed.

continuationAction 参数为 nullThe continuationAction argument is null.

示例

下面的示例创建一个前面的任务,该任务使用尼斯筛法的埃拉托色计算1与用户输入的值之间的质数。The following example creates an antecedent task that uses the Sieve of Eratosthenes to calculate the prime numbers between 1 and a value entered by the user. 数组用于保存有关质数的信息。An array is used to hold information about the prime numbers. 数组索引表示该数字,并且该元素的值指示该数字是复合的 (其值是 true) 还是质数 (其值 false) 。The array index represents the number, and the element's value indicates whether that number is composite (its value is true) or prime (its value is false). 然后,将此任务传递到延续任务,该任务负责从整数数组中提取质数并显示它们。This task is then passed to a continuation task, which is responsible for extracting the prime numbers from the integer array and displaying them.

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 将不会计划执行,直到当前任务已完成,该任务是否已完成,因为该任务已成功完成、是否由于未经处理的异常而出错,或由于被取消而导致退出。The returned Task will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting early due to being canceled.

另请参阅

适用于

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

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

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

scheduler
TaskScheduler

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

返回

Task

一个新的延续 TaskA new continuation Task.

例外

已释放了 Task<TResult>The Task<TResult> has been disposed.

continuationAction 参数为 nullThe continuationAction argument is null.

- 或 --or- scheduler 参数为 nullThe scheduler argument is null.

注解

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

另请参阅

适用于

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

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

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

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

参数

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

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

state
Object

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

cancellationToken
CancellationToken

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

continuationOptions
TaskContinuationOptions

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

scheduler
TaskScheduler

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

返回

Task<TNewResult>

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

例外

scheduler 参数为 nullThe scheduler argument is null.

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

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

注解

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

continuationFunction 执行时,应返回 Task<TResult>The continuationFunction, when executed, should return a Task<TResult>. 此任务的完成状态将传输到从调用返回的任务 Task<TResult>.ContinueWithThis task's completion state will be transferred to the task returned from the Task<TResult>.ContinueWith call.

另请参阅

适用于

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

创建根据 continuationOptions 中指定的条件加以执行的延续任务。Creates a continuation that executes according the condition specified in 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

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

参数

continuationFunction
Func<Task<TResult>,TNewResult>

根据 continuationOptions 中指定的条件运行函数。A function to run according the condition specified in continuationOptions.

在运行时,委托将作为一个参数传递给此完成的任务。When run, the delegate will be passed as an argument this completed task.

cancellationToken
CancellationToken

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

continuationOptions
TaskContinuationOptions

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

scheduler
TaskScheduler

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

返回

Task<TNewResult>

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

例外

已释放了 Task<TResult>The Task<TResult> has been disposed.

- 或 --or- 创建了 cancellationTokenCancellationTokenSource 已经被释放。The CancellationTokenSource that created cancellationToken has already been disposed.

continuationFunction 参数为 nullThe continuationFunction argument is null.

- 或 --or- scheduler 参数为 nullThe scheduler argument is null.

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

注解

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

continuationFunction 执行时,应返回 Task<TResult>The continuationFunction, when executed, should return a Task<TResult>.

另请参阅

适用于

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

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

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

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

参数

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

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

state
Object

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

scheduler
TaskScheduler

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

返回

Task<TNewResult>

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

例外

scheduler 参数为 nullThe scheduler argument is null.

注解

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

另请参阅

适用于

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

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

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

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

参数

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

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

state
Object

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

continuationOptions
TaskContinuationOptions

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

返回

Task<TNewResult>

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

例外

continuationFunction 参数为 nullThe continuationFunction argument is null.

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

注解

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

continuationFunction 执行时,应返回 Task<TResult>The continuationFunction, when executed, should return a Task<TResult>. 此任务的完成状态将传输到从 System.threading.tasks.task.continuewith 调用返回的任务。This task's completion state will be transferred to the task returned from the ContinueWith call.

另请参阅

适用于

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

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

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

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

参数

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

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

state
Object

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

cancellationToken
CancellationToken

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

返回

Task<TNewResult>

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

例外

continuationFunction 参数为 nullThe continuationFunction argument is null.

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

注解

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

另请参阅

适用于

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

创建根据 continuationOptions 中指定的条件加以执行的延续任务。Creates a continuation that executes according the condition specified in 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

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

参数

continuationFunction
Func<Task<TResult>,TNewResult>

根据 continuationOptions 中指定的条件运行函数。A function to run according the condition specified in continuationOptions.

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

continuationOptions
TaskContinuationOptions

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

返回

Task<TNewResult>

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

例外

已释放了 Task<TResult>The Task<TResult> has been disposed.

continuationFunction 参数为 nullThe continuationFunction argument is null.

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

注解

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

continuationFunction 执行时,应返回 Task<TResult>The continuationFunction, when executed, should return a Task<TResult>.

另请参阅

适用于

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

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

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

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

参数

continuationFunction
Func<Task<TResult>,TNewResult>

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

cancellationToken
CancellationToken

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

返回

Task<TNewResult>

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

例外

已释放了 Task<TResult>The Task<TResult> has been disposed.

- 或 --or- 创建了 cancellationTokenCancellationTokenSource 已经被释放。The CancellationTokenSource that created cancellationToken has already been disposed.

continuationFunction 参数为 nullThe continuationFunction argument is null.

注解

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

另请参阅

适用于

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

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

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

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

参数

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

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

state
Object

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

返回

Task<TNewResult>

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

例外

continuationFunction 参数为 nullThe continuationFunction argument is null.

示例

下面的示例创建一个延续任务链。The following example creates a chain of continuation tasks. 每个任务都为方法的状态参数提供当前时间,即 DateTime 对象 ContinueWith(Action<Task,Object>, Object)Each task provides the current time, a DateTime object, for the state argument of the ContinueWith(Action<Task,Object>, Object) method. 每个 DateTime 值都表示创建继续任务的时间。Each DateTime value represents the time at which the continue task is created. 每个任务都将生成一个 DateTime 表示任务完成时间的第二个值。Each task produces as its result a second DateTime value that represents the time at which the task finishes. 所有任务完成后,该示例将显示每个延续任务的开始和结束日期和时间。After all tasks finish, the example displays the date and times at which each continuation task starts and finishes.

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> 将不会计划执行,直到当前任务已完成,该任务是否已完成,因为该任务已成功完成、是否由于未经处理的异常而发生故障,或由于被取消而发生错误。The returned Task<TResult> will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

另请参阅

适用于

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

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

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

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

参数

continuationFunction
Func<Task<TResult>,TNewResult>

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

返回

Task<TNewResult>

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

例外

已释放了 Task<TResult>The Task<TResult> has been disposed.

continuationFunction 参数为 nullThe continuationFunction argument is null.

注解

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

另请参阅

适用于

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

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

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

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

参数

continuationFunction
Func<Task<TResult>,TNewResult>

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

scheduler
TaskScheduler

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

返回

Task<TNewResult>

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

例外

已释放了 Task<TResult>The Task<TResult> has been disposed.

continuationFunction 参数为 nullThe continuationFunction argument is null.

- 或 --or- scheduler 参数为 nullThe scheduler argument is null.

注解

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

另请参阅

适用于