Task.ContinueWith メソッド

定義

ターゲットの Task が完了したときに非同期に実行する継続タスクを作成します。

オーバーロード

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

呼び出し元が提供した状態情報およびキャンセル トークンを受け取り、対象の Task の完了時に実行される継続タスクを作成します。 継続タスクは、指定した一連の条件に基づいて実行され、指定したスケジューラが使用されます。

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

対象のタスクが完了したときに、指定した TaskContinuationOptions に従って実行される継続タスクを作成します。 この継続タスクは、キャンセル トークンを受け取り、指定されたスケジューラを使用します。

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

呼び出し元が提供した状態情報を受け取り、対象の Task が完了したときに非同期的に実行される継続タスクを作成します。 継続タスクは、指定されたスケジューラを使用します。

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

呼び出し元が提供した状態情報を受け取り、対象の Task が完了したときに実行される継続タスクを作成します。 継続タスクは、指定した一連の条件に基づいて実行されます。

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

呼び出し元が提供した状態情報およびキャンセル トークンを受け取り、対象の Task の完了時に非同期的に実行される継続タスクを作成します。

ContinueWith(Action<Task>)

ターゲットの Task が完了したときに非同期に実行する継続タスクを作成します。

ContinueWith(Action<Task>, TaskContinuationOptions)

対象のタスクが完了したときに、指定した TaskContinuationOptions に従って実行される継続タスクを作成します。

ContinueWith(Action<Task>, CancellationToken)

キャンセル トークンを受け取って、対象の Task が完了したときに非同期的に実行される継続タスクを作成します。

ContinueWith(Action<Task,Object>, Object)

呼び出し元が提供した状態情報を受け取り、対象の Task が完了したときに実行される継続タスクを作成します。

ContinueWith(Action<Task>, TaskScheduler)

ターゲットの Task が完了したときに非同期に実行する継続タスクを作成します。 継続タスクは、指定されたスケジューラを使用します。

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

ターゲットの Task が完了したときに非同期に実行する継続タスクを作成します。 この継続タスクは、呼び出し元が提供した状態情報を受け取り、指定したスケジューラを使用します。

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

対象の Task が完了したときに、指定したタスク継続オプションに基づいて実行され、値を返す継続タスクを作成します。 この継続タスクは、呼び出し元が提供した状態情報とキャンセル トークンを受け取り、指定したスケジューラを使用します。

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

指定された継続のオプションに従って実行され、値を返す継続タスクを作成します。 継続タスクは、キャンセル トークンを渡され、指定されたスケジューラを使用します。

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

対象の Task が完了して値を返したときに非同期的に実行される継続タスクを作成します。 この継続タスクは、呼び出し元が提供した状態情報とキャンセル トークンを受け取ります。

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

対象の Task が完了したときに、指定したタスク継続オプションに基づいて実行される継続タスクを作成します。 この継続タスクは、呼び出し元が提供した状態情報を受け取ります。

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

指定された継続のオプションに従って実行され、値を返す継続タスクを作成します。

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

対象の Task が完了して値を返したときに非同期的に実行される継続タスクを作成します。 継続タスクは、指定されたスケジューラを使用します。

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

対象の Task が完了して値を返したときに非同期的に実行される継続タスクを作成します。 この継続タスクは、キャンセル トークンを受け取ります。

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

呼び出し元から提供される状態情報を受け取り、対象の Task が完了したときに非同期的に実行され、値を返す継続タスクを作成します。

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

対象の Task<TResult> が完了して値を返したときに非同期的に実行される継続タスクを作成します。

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

ソース:
Task.cs
ソース:
Task.cs
ソース:
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

例外

scheduler 引数が null です。

continuationOptions 引数が、TaskContinuationOptions の無効な値を指定しています。

指定された CancellationToken は既に破棄されています。

注釈

返された Task は、現在のタスクが完了するまで実行スケジュールされません。 パラメーターで指定された条件が continuationOptions 満たされない場合、継続タスクはスケジュールではなく取り消されます。

適用対象

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

ソース:
Task.cs
ソース:
Task.cs
ソース:
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

例外

トークンを作成した CancellationTokenSource は、既に破棄されています。

continuationAction 引数が null です。

または

scheduler 引数が null です。

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)

ソース:
Task.cs
ソース:
Task.cs
ソース:
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

例外

scheduler 引数が null です。

注釈

現在のタスクが正常に完了するまで、未処理の例外によるエラーが発生した場合、または取り消されるために早期に終了するまで、現在のタスクが完了するまで、返 Task された は実行スケジュールされません。

適用対象

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

ソース:
Task.cs
ソース:
Task.cs
ソース:
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

例外

continuationAction 引数が null です。

continuationOptions 引数が、TaskContinuationOptions の無効な値を指定しています。

注釈

返された Task は、現在のタスクが完了するまで実行スケジュールされません。 パラメーターで指定された継続条件が continuationOptions 満たされない場合、継続タスクはスケジュールではなく取り消されます。

適用対象

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

ソース:
Task.cs
ソース:
Task.cs
ソース:
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

例外

continuationAction 引数が null です。

指定された CancellationToken は既に破棄されています。

注釈

現在のタスクが正常に完了するまで、未処理の例外によるエラーが発生した場合、または取り消されるために早期に終了するまで、現在のタスクが完了するまで、返 Task された は実行スケジュールされません。

適用対象

ContinueWith(Action<Task>)

ソース:
Task.cs
ソース:
Task.cs
ソース:
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

例外

continuationAction 引数が null です。

次の例では、100 個のランダムな日付と時刻の値を配列に設定するタスクを定義します。 配列が ContinueWith(Action<Task>) 完全に設定されると、 メソッドを使用して最も古い日付と最新の日付の値を選択します。

using System;
using System.Threading.Tasks;

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

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

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

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

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

        dates)

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

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

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

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


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

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

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

コンソール アプリケーションは継続タスクの実行前に終了する可能性があるため、 メソッドが呼び出され、 Wait() 例が終了する前に継続の実行が完了します。

その他の例については、「 継続タスクを使用したタスクの連結」を参照してください。

注釈

現在のタスクが正常に完了するまで、未処理の例外によるエラーが発生した場合、または取り消されるために早期に終了するまで、現在のタスクが完了するまで、返 Task された は実行スケジュールされません。

適用対象

ContinueWith(Action<Task>, TaskContinuationOptions)

ソース:
Task.cs
ソース:
Task.cs
ソース:
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

例外

continuationAction 引数が null です。

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)

ソース:
Task.cs
ソース:
Task.cs
ソース:
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

例外

トークンを作成した CancellationTokenSource は、既に破棄されています。

continuationAction 引数が null です。

注釈

現在のタスクが正常に完了するまで、未処理の例外によるエラーが発生した場合、または取り消されるために早期に終了するまで、現在のタスクが完了するまで、返 Task された は実行スケジュールされません。

適用対象

ContinueWith(Action<Task,Object>, Object)

ソース:
Task.cs
ソース:
Task.cs
ソース:
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

継続アクションによって使用されるデータを表すオブジェクト。

戻り値

新しい継続タスク。

例外

continuationAction 引数が null です。

注釈

現在のタスクが正常に完了するか、ハンドルされない例外によるエラーが発生したか、取り消しが原因で早期に終了したかに関係なく、現在のタスクが完了するまで、返された Task は実行スケジュールされません。

適用対象

ContinueWith(Action<Task>, TaskScheduler)

ソース:
Task.cs
ソース:
Task.cs
ソース:
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 は破棄されています。

continuationAction 引数が null です。

または

scheduler 引数が null です。

注釈

現在のタスクが正常に完了するまで、未処理の例外によるエラーが発生した場合、または取り消されるために早期に終了するまで、現在のタスクが完了するまで、返 Task された は実行スケジュールされません。

適用対象

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

ソース:
Task.cs
ソース:
Task.cs
ソース:
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>

例外

scheduler 引数が null です。

注釈

現在のタスクが正常に完了するまで、未処理の例外によるエラーが発生した場合、または取り消されるために早期に終了するまで、現在のタスクが完了するまで、返 Task<TResult> された は実行スケジュールされません。

適用対象

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

ソース:
Task.cs
ソース:
Task.cs
ソース:
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>

例外

scheduler 引数が null です。

continuationOptions 引数が、TaskContinuationOptions の無効な値を指定しています。

指定された CancellationToken は既に破棄されています。

注釈

返された Task<TResult> は、現在のタスクが完了するまで実行スケジュールされません。 パラメーターで指定された条件が continuationOptions 満たされない場合、継続タスクはスケジュールではなく取り消されます。

適用対象

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

ソース:
Task.cs
ソース:
Task.cs
ソース:
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. When run に従って実行する関数は、完了したタスクを引数として渡されます。

cancellationToken
CancellationToken

新しい継続タスクに割り当てられる CancellationToken

continuationOptions
TaskContinuationOptions

継続タスクのスケジュールおよびその動作を設定するオプション。 これには、OnlyOnCanceled などの基準および ExecuteSynchronously などの実行オプションが含まれます。

scheduler
TaskScheduler

継続タスクに関連付け、それを実行するために使用する TaskScheduler

戻り値

新しい継続 Task<TResult>

例外

Task は破棄されています。

または

トークンを作成した CancellationTokenSource は、既に破棄されています。

continuationFunction 引数が null です。

または

scheduler 引数が null です。

continuationOptions 引数が、TaskContinuationOptions の無効な値を指定しています。

次の例は、継続オプションで ContinueWith メソッドを使用する方法を示しています。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

let failure =
    fun () ->

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

        raise (InvalidOperationException "SIMULATED EXCEPTION")

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

let rollback =
    fun (antecendent: Task) ->

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

注釈

返された Task<TResult> は、現在のタスクが完了するまで実行スケジュールされません。 パラメーターで指定された条件が continuationOptions 満たされない場合、継続タスクはスケジュールではなく取り消されます。

適用対象

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

ソース:
Task.cs
ソース:
Task.cs
ソース:
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>

例外

continuationFunction 引数が null です。

指定された CancellationToken は既に破棄されています。

注釈

現在のタスクが正常に完了するまで、未処理の例外によるエラーが発生した場合、または取り消されるために早期に終了するまで、現在のタスクが完了するまで、返 Task<TResult> された は実行スケジュールされません。

適用対象

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

ソース:
Task.cs
ソース:
Task.cs
ソース:
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>

例外

continuationFunction 引数が null です。

continuationOptions 引数が、TaskContinuationOptions の無効な値を指定しています。

注釈

返された Task<TResult> は、現在のタスクが完了するまで実行スケジュールされません。 パラメーターで指定された継続条件が continuationOptions 満たされない場合、継続タスクはスケジュールではなく取り消されます。

適用対象

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

ソース:
Task.cs
ソース:
Task.cs
ソース:
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 は破棄されています。

continuationFunction 引数が null です。

continuationOptions 引数が、TaskContinuationOptions の無効な値を指定しています。

注釈

返された Task<TResult> は、現在のタスクが完了するまで実行スケジュールされません。 パラメーターで指定された継続条件が continuationOptions 満たされない場合、継続タスクはスケジュールではなく取り消されます。

適用対象

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

ソース:
Task.cs
ソース:
Task.cs
ソース:
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 は破棄されています。

continuationFunction 引数が null です。

または

scheduler 引数が null です。

注釈

現在のタスクが正常に完了するまで、未処理の例外によるエラーが発生した場合、または取り消されるために早期に終了するまで、現在のタスクが完了するまで、返 Task<TResult> された は実行スケジュールされません。

適用対象

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

ソース:
Task.cs
ソース:
Task.cs
ソース:
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 は破棄されています。

または

トークンを作成した CancellationTokenSource は、既に破棄されています。

continuationFunction 引数が null です。

注釈

現在のタスクが正常に完了するまで、未処理の例外によるエラーが発生した場合、または取り消されるために早期に終了するまで、現在のタスクが完了するまで、返 Task<TResult> された は実行スケジュールされません。

適用対象

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

ソース:
Task.cs
ソース:
Task.cs
ソース:
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>

例外

continuationFunction 引数が null です。

注釈

現在のタスクが正常に完了するまで、未処理の例外によるエラーが発生した場合、または取り消されるために早期に終了するまで、現在のタスクが完了するまで、返 Task<TResult> された は実行スケジュールされません。

適用対象

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

ソース:
Task.cs
ソース:
Task.cs
ソース:
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 は破棄されています。

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> された は実行スケジュールされません。

適用対象