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

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

注釈

適用対象

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>

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>

state: Object

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

continuationOptions: TaskContinuationOptions

戻り値

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>

state: Object

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

cancellationToken: CancellationToken

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

戻り値

Task

新しい継続 Task。

例外

ArgumentNullException

continuationAction 引数が null です。

ObjectDisposedException

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

注釈

適用対象

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

戻り値

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

注釈

適用対象

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 です。

注釈

適用対象

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() 例が終了する前に継続の実行が完了します。

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

注釈

適用対象

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 です。

注釈

適用対象

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

戻り値

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

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

cancellationToken: CancellationToken

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

continuationOptions: TaskContinuationOptions

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 は既に破棄されています。

注釈

適用対象

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 です。

注釈

適用対象

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

戻り値

Task<TResult>

新しい継続 Task<TResult>。

例外

ObjectDisposedException

Task は破棄されています。

ArgumentNullException

continuationFunction 引数が null です。

ArgumentOutOfRangeException

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

注釈

適用対象

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 です。

注釈

適用対象

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

注釈

適用対象

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 です。

注釈

適用対象