Task.ContinueWith 方法

參考

定義

命名空間:: System.Threading.Tasks

組件:: System.Threading.Tasks.dll

組件:: System.Runtime.dll

組件:: mscorlib.dll

組件:: netstandard.dll

重要

部分資訊涉及發行前產品，在發行之前可能會有大幅修改。 Microsoft 對此處提供的資訊，不做任何明確或隱含的瑕疵擔保。

建立當目標 Task 完成時非同步執行的接續。

多載

ContinueWith(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	建立當目標 Task 完成時，會接收呼叫端提供的狀態資訊和取消語彙基元，並執行的接續。接續會根據一組指定的條件執行，並使用指定的排程器。
ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler)	建立當目標工作完成時，會根據指定之 TaskContinuationOptions 執行的接續。接續會接收取消語彙基元，並使用指定的排程器。
ContinueWith(Action<Task,Object>, Object, TaskScheduler)	建立當目標 Task 完成時，會接收呼叫端提供的狀態資訊並非同步執行的接續。接續會使用指定的排程器。
ContinueWith(Action<Task,Object>, Object, TaskContinuationOptions)	建立當目標 Task 完成時，會接收呼叫端提供的狀態資訊並執行的接續。接續會根據一組指定的條件執行。
ContinueWith(Action<Task,Object>, Object, CancellationToken)	建立當目標 Task 完成時，會接收呼叫端提供的狀態資訊和取消語彙基元，並非同步執行的接續。
ContinueWith(Action<Task,Object>, Object)	建立當目標 Task 完成時，會接收呼叫端提供的狀態資訊並執行的接續。
ContinueWith(Action<Task>, TaskContinuationOptions)	建立當目標工作完成時，會根據指定之 TaskContinuationOptions 執行的接續。
ContinueWith(Action<Task>, CancellationToken)	建立當目標 Task 完成時，會接收取消語彙基元並非同步執行的接續。
ContinueWith(Action<Task>)	建立當目標 Task 完成時非同步執行的接續。
ContinueWith(Action<Task>, TaskScheduler)	建立當目標 Task 完成時非同步執行的接續。接續會使用指定的排程器。
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskContinuationOptions)	建立當目標 Task 完成時，會根據指定的工作接續選項來執行的接續。接續會接收呼叫端提供的狀態資訊。
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	建立當目標 Task 完成並傳回值時，會根據指定的工作接續選項來執行的接續。接續會接收呼叫端提供的狀態資訊和取消語彙基元，並使用指定的排程器。
ContinueWith<TResult>(Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	建立會根據指定之接續選項執行並傳回值的接續。接續會接收取消語彙基元，並使用指定的排程器。
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskScheduler)	建立當目標 Task 完成時非同步執行的接續。接續會接收呼叫端提供的狀態資訊，並使用指定的排程器。
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken)	建立當目標 Task 完成並傳回值時非同步執行的接續。接續會接收呼叫端提供的狀態資訊和取消語彙基元。
ContinueWith<TResult>(Func<Task,TResult>, CancellationToken)	建立當目標 Task 完成並傳回值時非同步執行的接續。接續會接收取消語彙基元。
ContinueWith<TResult>(Func<Task,TResult>, TaskContinuationOptions)	建立會根據指定之接續選項執行並傳回值的接續。
ContinueWith<TResult>(Func<Task,Object,TResult>, Object)	建立當目標 Task 完成並傳回值時，會接收呼叫端提供的狀態資訊並非同步執行的接續。
ContinueWith<TResult>(Func<Task,TResult>)	建立當目標 Task<TResult> 完成並傳回值時非同步執行的接續。
ContinueWith<TResult>(Func<Task,TResult>, TaskScheduler)	建立當目標 Task 完成並傳回值時非同步執行的接續。接續會使用指定的排程器。

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

建立當目標 Task 完成時，會接收呼叫端提供的狀態資訊和取消語彙基元，並執行的接續。接續會根據一組指定的條件執行，並使用指定的排程器。

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

public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object> continuationAction, object state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);

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

member this.ContinueWith : Action<System.Threading.Tasks.Task, obj> * obj * System.Threading.CancellationToken * System.Threading.Tasks.TaskContinuationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task

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

參數

continuationAction: Action<Task,Object>

當 Task 完成時要執行的動作。當執行時，完成的工作會傳遞至委派，並以呼叫端提供狀態的物件做為引數。

state: Object

物件，表示接續動作所使用的資料。

cancellationToken: CancellationToken

要指派給新接續工作的 CancellationToken。

continuationOptions: TaskContinuationOptions

接續工作的排程時間及其行為方式的適用選項。這包含準則 (如 OnlyOnCanceled) 和執行選項 (如 ExecuteSynchronously)。

scheduler: TaskScheduler

要與接續工作產生關聯且於執行時使用的 TaskScheduler。

傳回

Task

新的接續 Task。

例外狀況

ArgumentNullException

scheduler 引數為 null。

ArgumentOutOfRangeException

continuationOptions 引數指定的 TaskContinuationOptions 值不正確。

ObjectDisposedException

提供的 CancellationToken 已經過處置。

備註

傳回 Task 的將不會排程執行，直到目前的工作完成為止。如果不符合透過 continuationOptions 參數指定的準則，則會取消接續工作，而不是排程工作。

適用於

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

建立當目標工作完成時，會根據指定之 TaskContinuationOptions 執行的接續。接續會接收取消語彙基元，並使用指定的排程器。

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

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

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

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

參數

continuationAction: Action<Task>

要根據指定的 continuationOptions 執行的動作。執行時，會將已完成的工作當做引數傳遞給委派。

cancellationToken: CancellationToken

要指派給新接續工作的 CancellationToken。

continuationOptions: TaskContinuationOptions

接續工作的排程時間及其行為方式的適用選項。這包含準則 (如 OnlyOnCanceled) 和執行選項 (如 ExecuteSynchronously)。

scheduler: TaskScheduler

要與接續工作產生關聯且於執行時使用的 TaskScheduler。

傳回

Task

新的接續 Task。

例外狀況

ObjectDisposedException

已處置建立語彙基元的 CancellationTokenSource。

ArgumentNullException

continuationAction 引數為 null。

-或-

scheduler 引數為 null。

ArgumentOutOfRangeException

continuationOptions 引數指定的 TaskContinuationOptions 值不正確。

範例

以下是使用 ContinueWith 在背景和使用者介面執行緒上執行工作的範例。

private void Button1_Click(object sender, EventArgs e)
{
   var backgroundScheduler = TaskScheduler.Default;
   var uiScheduler = TaskScheduler.FromCurrentSynchronizationContext();
   Task.Factory.StartNew(delegate { DoBackgroundComputation(); },
                         backgroundScheduler).
   ContinueWith(delegate { UpdateUI(); }, uiScheduler).
                ContinueWith(delegate { DoAnotherBackgroundComputation(); },
                             backgroundScheduler).
                ContinueWith(delegate { UpdateUIAgain(); }, uiScheduler);
}

Private Sub Button1_Click(ByVal sender As System.Object,
                          ByVal e As System.EventArgs) Handles Button1.Click
   Dim backgroundScheduler = TaskScheduler.Default
   Dim uiScheduler = TaskScheduler.FromCurrentSynchronizationContext()

   Task.Factory.StartNew(Sub()
                           DoBackgroundComputation()
                         End Sub, backgroundScheduler).ContinueWith(Sub(t)
                            UpdateUI()
                         End Sub, uiScheduler).ContinueWith(Sub(t)
                            DoAnotherBackgroundComputation()
                         End Sub, backgroundScheduler).ContinueWith(Sub(t)
                            UpdateUIAgain()
                         End Sub, uiScheduler)
End Sub

備註

傳回 Task 的將不會排程執行，直到目前的工作完成為止。如果不符合透過 continuationOptions 參數指定的準則，則會取消接續工作，而不是排程工作。

適用於

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

建立當目標 Task 完成時，會接收呼叫端提供的狀態資訊並非同步執行的接續。接續會使用指定的排程器。

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

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

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

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

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

參數

continuationAction: Action<Task,Object>

當 Task 完成時要執行的動作。當執行時，完成的工作會傳遞至委派，並以呼叫端提供狀態的物件做為引數。

state: Object

物件，表示接續動作所使用的資料。

scheduler: TaskScheduler

要與接續工作產生關聯且於執行時使用的 TaskScheduler。

傳回

Task

新的接續 Task。

例外狀況

ArgumentNullException

scheduler 引數為 null。

備註

傳回 Task 的將不會排程執行，直到目前的工作完成為止，無論是因為順利執行而完成、因未處理的例外狀況而發生錯誤，或因為取消而提早結束。

適用於

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

建立當目標 Task 完成時，會接收呼叫端提供的狀態資訊並執行的接續。接續會根據一組指定的條件執行。

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

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

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

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

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

參數

continuationAction: Action<Task,Object>

當 Task 完成時要執行的動作。當執行時，完成的工作會傳遞至委派，並以呼叫端提供狀態的物件做為引數。

state: Object

物件，表示接續動作所使用的資料。

continuationOptions: TaskContinuationOptions

接續工作的排程時間及其行為方式的適用選項。這包含準則 (如 OnlyOnCanceled) 和執行選項 (如 ExecuteSynchronously)。

傳回

Task

新的接續 Task。

例外狀況

ArgumentNullException

continuationAction 引數為 null。

ArgumentOutOfRangeException

continuationOptions 引數指定的 TaskContinuationOptions 值不正確。

備註

在目前的工作完成之前，不會排程傳 Task 回的執行。如果不符合透過 continuationOptions 參數指定的接續準則，則會取消接續工作，而不是排程。

適用於

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

建立當目標 Task 完成時，會接收呼叫端提供的狀態資訊和取消語彙基元，並非同步執行的接續。

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

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

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

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

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

參數

continuationAction: Action<Task,Object>

當 Task 完成時要執行的動作。當執行時，完成的工作會傳遞至委派，並以呼叫端提供狀態的物件做為引數。

state: Object

物件，表示接續動作所使用的資料。

cancellationToken: CancellationToken

要指派給新接續工作的 CancellationToken。

傳回

Task

新的接續 Task。

例外狀況

ArgumentNullException

continuationAction 引數為 null。

ObjectDisposedException

提供的 CancellationToken 已經過處置。

備註

傳回 Task 的將不會排程執行，直到目前的工作完成為止，無論是因為順利執行而完成、因未處理的例外狀況而發生錯誤，或因為取消而提早結束。

適用於

ContinueWith(Action<Task,Object>, Object)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

建立當目標 Task 完成時，會接收呼叫端提供的狀態資訊並執行的接續。

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

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

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

member this.ContinueWith : Action<System.Threading.Tasks.Task, obj> * obj -> System.Threading.Tasks.Task

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

參數

continuationAction: Action<Task,Object>

當工作完成時要執行的動作。執行時，會將已完成的工作和呼叫端提供的狀態物件當做引數傳遞給委派。

state: Object

物件，表示接續動作所使用的資料。

傳回

Task

新的接續工作。

例外狀況

ArgumentNullException

continuationAction 引數為 null。

備註

傳回 Task 的將不會排程執行，直到目前的工作完成、因為順利執行而完成、因未處理的例外狀況而發生錯誤，或因取消而提早結束。

適用於

ContinueWith(Action<Task>, TaskContinuationOptions)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

建立當目標工作完成時，會根據指定之 TaskContinuationOptions 執行的接續。

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

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

member this.ContinueWith : Action<System.Threading.Tasks.Task> * System.Threading.Tasks.TaskContinuationOptions -> System.Threading.Tasks.Task

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

參數

continuationAction: Action<Task>

要根據指定的 continuationOptions 執行的動作。執行時，會將已完成的工作當做引數傳遞給委派。

continuationOptions: TaskContinuationOptions

接續工作的排程時間及其行為方式的適用選項。這包含準則 (如 OnlyOnCanceled) 和執行選項 (如 ExecuteSynchronously)。

傳回

Task

新的接續 Task。

例外狀況

ArgumentNullException

continuationAction 引數為 null。

ArgumentOutOfRangeException

continuationOptions 引數指定的 TaskContinuationOptions 值不正確。

範例

下列範例示範如何使用 TaskContinuationOptions 來指定接續工作在前項工作完成時應該同步執行。 (如果呼叫指定的工作已完成 ContinueWith ，同步接續會在呼叫 ContinueWith .) 的執行緒上執行

public class TaskCounter
{
   private volatile int _count;

   public void Track(Task t)
   {
      if (t == null) throw new ArgumentNullException("t");
      Interlocked.Increment(ref _count);
      t.ContinueWith(ct => Interlocked.Decrement(ref _count), TaskContinuationOptions.ExecuteSynchronously);
   }

   public int NumberOfActiveTasks { get { return _count; } }
}

Public Class TaskCounter
   Private _count as Integer

   Public Sub Track(ByVal t as Task)
      If t is Nothing Then Throw New ArgumentNullException("t")
      Interlocked.Increment(_count)
      t.ContinueWith(Sub(ct)
                        Interlocked.Decrement(_count)
                     End Sub,
                     TaskContinuationOptions.ExecuteSynchronously)
   End Sub

   Public ReadOnly Property NumberOfActiveTasks As Integer
      Get
         Return _count
      End Get
   End Property
End Class

備註

在目前的工作完成之前，不會排程傳 Task 回的執行。如果不符合透過 continuationOptions 參數指定的接續準則，則會取消接續工作，而不是排程。

適用於

ContinueWith(Action<Task>, CancellationToken)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

建立當目標 Task 完成時，會接收取消語彙基元並非同步執行的接續。

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

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

member this.ContinueWith : Action<System.Threading.Tasks.Task> * System.Threading.CancellationToken -> System.Threading.Tasks.Task

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

參數

continuationAction: Action<Task>

當 Task 完成時要執行的動作。執行時，會將已完成的工作當做引數傳遞給委派。

cancellationToken: CancellationToken

要指派給新接續工作的 CancellationToken。

傳回

Task

新的接續 Task。

例外狀況

ObjectDisposedException

已處置建立語彙基元的 CancellationTokenSource。

ArgumentNullException

continuationAction 引數為 null。

備註

傳回 Task 的將不會排程執行，直到目前的工作完成為止，無論是因為順利執行而完成、因未處理的例外狀況而發生錯誤，或因為取消而提早結束。

適用於

ContinueWith(Action<Task>)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

建立當目標 Task 完成時非同步執行的接續。

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

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

member this.ContinueWith : Action<System.Threading.Tasks.Task> -> System.Threading.Tasks.Task

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

參數

continuationAction: Action<Task>

當 Task 完成時要執行的動作。執行時，會將已完成的工作當做引數傳遞給委派。

傳回

Task

新的接續 Task。

例外狀況

ArgumentNullException

continuationAction 引數為 null。

範例

下列範例會定義以 100 個隨機日期和時間值填入陣列的工作。它會使用 ContinueWith(Action<Task>) 方法，在陣列完全填入之後，選取最早和最新的日期值。

using System;
using System.Threading.Tasks;

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

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

open System
open System.Threading.Tasks

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

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

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

        dates)

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

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

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

            printfn $"Earliest date: {earliest}"
            printfn $"Latest date: {latest}")
    )
// Since a console application otherwise terminates, wait for the continuation to complete.
continuationTask.Wait()


// The example displays output like the following:
//       Earliest date: 2/11/0110 12:03:41 PM
//       Latest date: 7/29/9989 2:14:49 PM

Imports System.Threading.Tasks

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

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

由於主控台應用程式可能會在接續工作執行之前終止，因此 Wait() 會呼叫方法，以確保接續會在範例結束之前完成執行。

如需其他範例，請參閱使用接續工作鏈結工作。

備註

傳回 Task 的將不會排程執行，直到目前的工作完成為止，無論是因為順利執行而完成、因未處理的例外狀況而發生錯誤，或因為取消而提早結束。

適用於

ContinueWith(Action<Task>, TaskScheduler)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

建立當目標 Task 完成時非同步執行的接續。接續會使用指定的排程器。

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

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

member this.ContinueWith : Action<System.Threading.Tasks.Task> * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task

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

參數

continuationAction: Action<Task>

當 Task 完成時要執行的動作。執行時，會將已完成的工作當做引數傳遞給委派。

scheduler: TaskScheduler

要與接續工作產生關聯且於執行時使用的 TaskScheduler。

傳回

Task

新的接續 Task。

例外狀況

ObjectDisposedException

Task 已經處置。

ArgumentNullException

continuationAction 引數為 null。

-或-

scheduler 引數為 null。

備註

傳回 Task 的將不會排程執行，直到目前的工作完成為止，無論是因為順利執行而完成、因未處理的例外狀況而發生錯誤，或因為取消而提早結束。

適用於

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

建立當目標 Task 完成時，會根據指定的工作接續選項來執行的接續。接續會接收呼叫端提供的狀態資訊。

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

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

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

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

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

類型參數

TResult

接續作業所產生的結果類型。

參數

continuationFunction: Func<Task,Object,TResult>

當 Task 完成時要執行的函式。當執行時，完成的工作會傳遞至委派，並以呼叫端提供狀態的物件做為引數。

state: Object

物件，表示接續函式所使用的資料。

continuationOptions: TaskContinuationOptions

接續工作的排程時間及其行為方式的適用選項。這包含準則 (如 OnlyOnCanceled) 和執行選項 (如 ExecuteSynchronously)。

傳回

Task<TResult>

新的接續 Task<TResult>。

例外狀況

ArgumentNullException

continuationFunction 引數為 null。

ArgumentOutOfRangeException

continuationOptions 引數指定的 TaskContinuationOptions 值不正確。

備註

在目前的工作完成之前，不會排程傳 Task<TResult> 回的執行。如果不符合透過 continuationOptions 參數指定的接續準則，則會取消接續工作，而不是排程。

適用於

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

建立當目標 Task 完成並傳回值時，會根據指定的工作接續選項來執行的接續。接續會接收呼叫端提供的狀態資訊和取消語彙基元，並使用指定的排程器。

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

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

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

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

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

類型參數

TResult

接續作業所產生的結果類型。

參數

continuationFunction: Func<Task,Object,TResult>

當 Task 完成時要執行的函式。當執行時，完成的工作會傳遞至委派，並以呼叫端提供狀態的物件做為引數。

state: Object

物件，表示接續函式所使用的資料。

cancellationToken: CancellationToken

要指派給新接續工作的 CancellationToken。

continuationOptions: TaskContinuationOptions

接續工作的排程時間及其行為方式的適用選項。這包含準則 (如 OnlyOnCanceled) 和執行選項 (如 ExecuteSynchronously)。

scheduler: TaskScheduler

要與接續工作產生關聯且於執行時使用的 TaskScheduler。

傳回

Task<TResult>

新的接續 Task<TResult>。

例外狀況

ArgumentNullException

scheduler 引數為 null。

ArgumentOutOfRangeException

continuationOptions 引數指定的 TaskContinuationOptions 值不正確。

ObjectDisposedException

提供的 CancellationToken 已經過處置。

備註

傳回 Task<TResult> 的將不會排程執行，直到目前的工作完成為止。如果不符合透過 continuationOptions 參數指定的準則，則會取消接續工作，而不是排程工作。

適用於

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

建立會根據指定之接續選項執行並傳回值的接續。接續會接收取消語彙基元，並使用指定的排程器。

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

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

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

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

類型參數

TResult

接續作業所產生的結果類型。

參數

continuationFunction: Func<Task,TResult>

根據指定的 continuationOptions. [執行時] 執行的函式，委派將會以引數的形式傳遞已完成的工作。

cancellationToken: CancellationToken

要指派給新接續工作的 CancellationToken。

continuationOptions: TaskContinuationOptions

接續工作的排程時間及其行為方式的適用選項。這包含準則 (如 OnlyOnCanceled) 和執行選項 (如 ExecuteSynchronously)。

scheduler: TaskScheduler

要與接續工作產生關聯且於執行時使用的 TaskScheduler。

傳回

Task<TResult>

新的接續 Task<TResult>。

例外狀況

ObjectDisposedException

Task 已經處置。

-或-

已處置建立語彙基元的 CancellationTokenSource。

ArgumentNullException

continuationFunction 引數為 null。

-或-

scheduler 引數為 null。

ArgumentOutOfRangeException

continuationOptions 引數指定的 TaskContinuationOptions 值不正確。

範例

下列範例示範如何搭配接續選項使用 ContinueWith 方法：

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Demonstrated features:
//      TaskContinuationOptions
//		Task.ContinueWith()
// 		Task.Factory
//		Task.Wait()
// Expected results:
// 		This sample demonstrates branched continuation sequences - Task+Commit or Task+Rollback.
//      Notice that no if statements are used.
//		The first sequence is successful - tran1 and commitTran1 are executed. rollbackTran1 is canceled.
//		The second sequence is unsuccessful - tran2 and rollbackTran2 are executed. tran2 is faulted, and commitTran2 is canceled.
// Documentation:
//		http://msdn.microsoft.com/library/system.threading.tasks.taskcontinuationoptions(VS.100).aspx
let success =
    fun () ->
        printfn $"Task={Task.CurrentId}, Thread={Thread.CurrentThread.ManagedThreadId}: Begin successful transaction"

let failure =
    fun () ->

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

        raise (InvalidOperationException "SIMULATED EXCEPTION")

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

let rollback =
    fun (antecendent: Task) ->

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

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

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

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

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

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

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

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

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

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

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

// The following task gets scheduled only if tran2 DOES NOT complete successfully
let rollbackTran2 =
    tran2.ContinueWith(Action<Task> rollback, TaskContinuationOptions.NotOnRanToCompletion)

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

Imports System.Threading
Imports System.Threading.Tasks

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

備註

適用於

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

建立當目標 Task 完成時非同步執行的接續。接續會接收呼叫端提供的狀態資訊，並使用指定的排程器。

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

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

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

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

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

類型參數

TResult

接續作業所產生的結果類型。

參數

continuationFunction: Func<Task,Object,TResult>

當 Task 完成時要執行的函式。當執行時，完成的工作會傳遞至委派，並以呼叫端提供狀態的物件做為引數。

state: Object

物件，表示接續函式所使用的資料。

scheduler: TaskScheduler

要與接續工作產生關聯且於執行時使用的 TaskScheduler。

傳回

Task<TResult>

新的接續 Task<TResult>。

例外狀況

ArgumentNullException

scheduler 引數為 null。

備註

傳回 Task<TResult> 的將不會排程執行，直到目前的工作完成、因為執行成功而完成、因未處理的例外狀況而發生錯誤，或因取消而提早結束。

適用於

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

建立當目標 Task 完成並傳回值時非同步執行的接續。接續會接收呼叫端提供的狀態資訊和取消語彙基元。

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

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

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

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

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

類型參數

TResult

接續作業所產生的結果類型。

參數

continuationFunction: Func<Task,Object,TResult>

當 Task 完成時要執行的函式。當執行時，完成的工作會傳遞至委派，並以呼叫端提供狀態的物件做為引數。

state: Object

物件，表示接續函式所使用的資料。

cancellationToken: CancellationToken

要指派給新接續工作的 CancellationToken。

傳回

Task<TResult>

新的接續 Task<TResult>。

例外狀況

ArgumentNullException

continuationFunction 引數為 null。

ObjectDisposedException

提供的 CancellationToken 已經過處置。

備註

傳回 Task<TResult> 的將不會排程執行，直到目前的工作完成、因為執行成功而完成、因未處理的例外狀況而發生錯誤，或因取消而提早結束。

適用於

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

建立當目標 Task 完成並傳回值時非同步執行的接續。接續會接收取消語彙基元。

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

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

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

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

類型參數

TResult

接續作業所產生的結果類型。

參數

continuationFunction: Func<Task,TResult>

當 Task 完成時要執行的函式。執行時，會將已完成的工作當做引數傳遞給委派。

cancellationToken: CancellationToken

要指派給新接續工作的 CancellationToken。

傳回

Task<TResult>

新的接續 Task<TResult>。

例外狀況

ObjectDisposedException

Task 已經處置。

-或-

已處置建立語彙基元的 CancellationTokenSource。

ArgumentNullException

continuationFunction 引數為 null。

備註

傳回 Task<TResult> 的將不會排程執行，直到目前的工作完成、因為執行成功而完成、因未處理的例外狀況而發生錯誤，或因取消而提早結束。

適用於

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

建立會根據指定之接續選項執行並傳回值的接續。

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

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

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

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

類型參數

TResult

接續作業所產生的結果類型。

參數

continuationFunction: Func<Task,TResult>

要根據 continuationOptions 中指定之條件執行的函式。執行時，會將已完成的工作當做引數傳遞給委派。

continuationOptions: TaskContinuationOptions

接續工作的排程時間及其行為方式的適用選項。這包含準則 (如 OnlyOnCanceled) 和執行選項 (如 ExecuteSynchronously)。

傳回

Task<TResult>

新的接續 Task<TResult>。

例外狀況

ObjectDisposedException

Task 已經處置。

ArgumentNullException

continuationFunction 引數為 null。

ArgumentOutOfRangeException

continuationOptions 引數指定的 TaskContinuationOptions 值不正確。

備註

傳回 Task<TResult> 的將不會排程執行，直到目前的工作完成為止。如果不符合透過 continuationOptions 參數指定的接續準則，則會取消接續工作，而不是排程工作。

適用於

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

建立當目標 Task 完成並傳回值時，會接收呼叫端提供的狀態資訊並非同步執行的接續。

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

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

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

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

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

類型參數

TResult

接續作業所產生的結果類型。

參數

continuationFunction: Func<Task,Object,TResult>

當 Task 完成時要執行的函式。當執行時，完成的工作會傳遞至委派，並以呼叫端提供狀態的物件做為引數。

state: Object

物件，表示接續函式所使用的資料。

傳回

Task<TResult>

新的接續 Task<TResult>。

例外狀況

ArgumentNullException

continuationFunction 引數為 null。

備註

傳回 Task<TResult> 的將不會排程執行，直到目前的工作完成、因為執行成功而完成、因未處理的例外狀況而發生錯誤，或因取消而提早結束。

適用於

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

建立當目標 Task<TResult> 完成並傳回值時非同步執行的接續。

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

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

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

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

類型參數

TResult

接續作業所產生的結果類型。

參數

continuationFunction: Func<Task,TResult>

當 Task<TResult> 完成時要執行的函式。執行時，會將已完成的工作當做引數傳遞給委派。

傳回

Task<TResult>

新的接續工作。

例外狀況

ObjectDisposedException

Task 已經處置。

ArgumentNullException

continuationFunction 引數為 null。

範例

下列範例示範如何使用 ContinueWith 方法：

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

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

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

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

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

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

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

// Demonstrated features:
// 		Task.Factory
//		Task.ContinueWith()
//		Task.Wait()
// Expected results:
// 		A sequence of three unrelated tasks is created and executed in this order - alpha, beta, gamma.
//		A sequence of three related tasks is created - each task negates its argument and passes is to the next task: 5, -5, 5 is printed.
//		A sequence of three unrelated tasks is created where tasks have different types.
// Documentation:
//		http://msdn.microsoft.com/library/system.threading.tasks.taskfactory_members(VS.100).aspx
let action =
    fun str -> printfn $"Task={Task.CurrentId}, str=%s{str}, Thread={Thread.CurrentThread.ManagedThreadId}"

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

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

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

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

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

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

Task<int>
    .Factory.StartNew(fun () -> negate 6)
    .ContinueWith(Action<Task>(fun antecendent -> action "x"))
    .ContinueWith(fun antecendent -> negate 7)
    .Wait()

Imports System.Threading
Imports System.Threading.Tasks

Module ContinuationDemo

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

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


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

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


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

備註

傳回 Task<TResult> 的將不會排程執行，直到目前的工作完成、因為執行成功而完成、因未處理的例外狀況而發生錯誤，或因取消而提早結束。

適用於

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

建立當目標 Task 完成並傳回值時非同步執行的接續。接續會使用指定的排程器。

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

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

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

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

類型參數

TResult

接續作業所產生的結果類型。

參數

continuationFunction: Func<Task,TResult>

當 Task 完成時要執行的函式。執行時，會將已完成的工作當做引數傳遞給委派。

scheduler: TaskScheduler

要與接續工作產生關聯且於執行時使用的 TaskScheduler。

傳回

Task<TResult>

新的接續 Task<TResult>。

例外狀況

ObjectDisposedException

Task 已經處置。

ArgumentNullException

continuationFunction 引數為 null。

-或-

scheduler 引數為 null。

備註

傳回 Task<TResult> 的將不會排程執行，直到目前的工作完成、因為執行成功而完成、因未處理的例外狀況而發生錯誤，或因取消而提早結束。

適用於