Task<TResult>.ContinueWith Method

Source:

Future.cs

Source:

Task_T.cs

Source:

Future.cs

Source:

Future.cs

Source:

Future.cs

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

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

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

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

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

Parameters

Returns

A new continuation Task.

Exceptions

Remarks

The returned Task will not be scheduled for execution until the current task has completed. If the criteria specified through the continuationOptions parameter are not met, the continuation task will be canceled instead of scheduled.

See also

• Chaining Tasks by Using Continuation Tasks

Source:

Future.cs

Source:

Task_T.cs

Source:

Future.cs

Source:

Future.cs

Source:

Future.cs

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

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

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

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

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

Parameters

Returns

A new continuation Task.

Exceptions

Remarks

The returned Task will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

See also

• Chaining Tasks by Using Continuation Tasks

Source:

Future.cs

Source:

Task_T.cs

Source:

Future.cs

Source:

Future.cs

Source:

Future.cs

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

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

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

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

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

Parameters

Returns

A new continuation Task.

Exceptions

Remarks

The returned Task will not be scheduled for execution until the current task has completed. If the continuation criteria specified through the continuationOptions parameter are not met, the continuation task will be canceled instead of scheduled.

See also

• Chaining Tasks by Using Continuation Tasks

Source:

Future.cs

Source:

Task_T.cs

Source:

Future.cs

Source:

Future.cs

Source:

Future.cs

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

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

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

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

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

Parameters

Returns

A new continuation Task.

Exceptions

Remarks

The returned Task will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

See also

• Chaining Tasks by Using Continuation Tasks

Source:

Future.cs

Source:

Task_T.cs

Source:

Future.cs

Source:

Future.cs

Source:

Future.cs

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

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

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

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

Parameters

Returns

A new continuation Task.

Exceptions

Remarks

The returned Task will not be scheduled for execution until the current task has completed. If the criteria specified through the continuationOptions parameter are not met, the continuation task will be canceled instead of scheduled. For more information, see Chaining Tasks by Using Continuation Tasks.

See also

• Task Parallel Library (TPL)
• Task-based Asynchronous Programming
• Chaining Tasks by Using Continuation Tasks

Source:

Future.cs

Source:

Task_T.cs

Source:

Future.cs

Source:

Future.cs

Source:

Future.cs

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

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

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

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

Parameters

Returns

A new continuation Task.

Exceptions

Remarks

The returned Task will not be scheduled for execution until the current task has completed. If the continuation criteria specified through the continuationOptions parameter are not met, the continuation task will be canceled instead of scheduled.

For more information, see Chaining Tasks by Using Continuation Tasks.

See also

• Task Parallel Library (TPL)
• Task-based Asynchronous Programming
• Chaining Tasks by Using Continuation Tasks

Source:

Future.cs

Source:

Task_T.cs

Source:

Future.cs

Source:

Future.cs

Source:

Future.cs

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

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

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

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

Parameters

Returns

A new continuation task.

Exceptions

Examples

The following example creates an antecedent task that uses the Sieve of Eratosthenes to calculate the prime numbers between 1 and a value entered by the user. An array is used to hold information about the prime numbers. The array index represents the number, and the element's value indicates whether that number is composite (its value is true) or prime (its value is false). This task is then passed to a continuation task, which is responsible for extracting the prime numbers from the integer array and displaying them.

A cancellation token is passed to both the antecedent and the continuation task. A System.Timers.Timer object is used to define a timeout value of 100 milliseconds. If the event fires, the CancellationTokenSource.Cancel method is called, and the cancellation token is used to request cancellation of the tasks.

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

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

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

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

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

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

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

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

Module Example
 Dim ts As CancellationTokenSource

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

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

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

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

Typically, supplying a value of about 100,000 causes the timeout interval to expire and the Timer.Elapsed event to fire, and the cancellation request to be set.

Remarks

The returned Task will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

See also

• Task Parallel Library (TPL)
• Task-based Asynchronous Programming
• Chaining Tasks by Using Continuation Tasks

Source:

Future.cs

Source:

Task_T.cs

Source:

Future.cs

Source:

Future.cs

Source:

Future.cs

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

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

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

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

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

Parameters

Returns

A new continuation Task.

Exceptions

Examples

The following example creates a task that is passed an integer between 2 and 20 and returns an array that contains the first ten exponents (from n¹ to n¹⁰) of that number. A continuation task is then responsible for displaying the exponents. It is passed both the antecedent and the original number whose exponents the antecedent generates.

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

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

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

Imports System.Threading
Imports System.Threading.Tasks

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

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

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

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

Remarks

The returned Task will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

See also

• Chaining Tasks by Using Continuation Tasks

Source:

Future.cs

Source:

Task_T.cs

Source:

Future.cs

Source:

Future.cs

Source:

Future.cs

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

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

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

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

Parameters

Returns

A new continuation task.

Exceptions

Examples

The following example creates an antecedent task that uses the Sieve of Eratosthenes to calculate the prime numbers between 1 and a value entered by the user. An array is used to hold information about the prime numbers. The array index represents the number, and the element's value indicates whether that number is composite (its value is true) or prime (its value is false). This task is then passed to a continuation task, which is responsible for extracting the prime numbers from the integer array and displaying them.

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

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

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

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

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

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

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

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

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

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

Remarks

The returned Task will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting early due to being canceled.

See also

• Task Parallel Library (TPL)
• Task-based Asynchronous Programming
• Chaining Tasks by Using Continuation Tasks

Source:

Future.cs

Source:

Task_T.cs

Source:

Future.cs

Source:

Future.cs

Source:

Future.cs

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

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

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

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

Parameters

Returns

A new continuation Task.

Exceptions

Remarks

The returned Task will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

See also

• Task Parallel Library (TPL)
• Task-based Asynchronous Programming
• Chaining Tasks by Using Continuation Tasks

Source:

Future.cs

Source:

Task_T.cs

Source:

Future.cs

Source:

Future.cs

Source:

Future.cs

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

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

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

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

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

Type Parameters

Parameters

Returns

A new continuation Task<TResult>.

Exceptions

Remarks

The returned Task<TResult> will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

The continuationFunction, when executed, should return a Task<TResult>. This task's completion state will be transferred to the task returned from the Task<TResult>.ContinueWith call.

See also

• Chaining Tasks by Using Continuation Tasks

Source:

Future.cs

Source:

Task_T.cs

Source:

Future.cs

Source:

Future.cs

Source:

Future.cs

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

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

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

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

Type Parameters

Parameters

Returns

A new continuation Task<TResult>.

Exceptions

Remarks

The returned Task<TResult> will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

The continuationFunction, when executed, should return a Task<TResult>.

See also

• Task Parallel Library (TPL)
• Task-based Asynchronous Programming
• Chaining Tasks by Using Continuation Tasks

Source:

Future.cs

Source:

Task_T.cs

Source:

Future.cs

Source:

Future.cs

Source:

Future.cs

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

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

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

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

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

Type Parameters

Parameters

Returns

A new continuation Task<TResult>.

Exceptions

Remarks

The returned Task<TResult> will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

See also

• Chaining Tasks by Using Continuation Tasks

Source:

Future.cs

Source:

Task_T.cs

Source:

Future.cs

Source:

Future.cs

Source:

Future.cs

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

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

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

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

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

Type Parameters

Parameters

Returns

A new continuation Task<TResult>.

Exceptions

Remarks

The returned Task<TResult> will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

See also

• Chaining Tasks by Using Continuation Tasks

Source:

Future.cs

Source:

Task_T.cs

Source:

Future.cs

Source:

Future.cs

Source:

Future.cs

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

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

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

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

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

Type Parameters

Parameters

Returns

A new continuation Task<TResult>.

Exceptions

Remarks

The returned Task<TResult> will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

The continuationFunction, when executed, should return a Task<TResult>. This task's completion state will be transferred to the task returned from the ContinueWith call.

See also

• Chaining Tasks by Using Continuation Tasks

Source:

Future.cs

Source:

Task_T.cs

Source:

Future.cs

Source:

Future.cs

Source:

Future.cs

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

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

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

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

Type Parameters

Parameters

Returns

A new continuation Task<TResult>.

Exceptions

Remarks

The returned Task<TResult> will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

The continuationFunction, when executed, should return a Task<TResult>.

See also

• Task Parallel Library (TPL)
• Task-based Asynchronous Programming
• Chaining Tasks by Using Continuation Tasks

Source:

Future.cs

Source:

Task_T.cs

Source:

Future.cs

Source:

Future.cs

Source:

Future.cs

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

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

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

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

Type Parameters

Parameters

Returns

A new continuation Task<TResult>.

Exceptions

Remarks

The returned Task<TResult> will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

See also

• Task Parallel Library (TPL)
• Task-based Asynchronous Programming
• Chaining Tasks by Using Continuation Tasks

Source:

Future.cs

Source:

Task_T.cs

Source:

Future.cs

Source:

Future.cs

Source:

Future.cs

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

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

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

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

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

Type Parameters

Parameters

Returns

A new continuation Task<TResult>.

Exceptions

Examples

The following example creates a chain of continuation tasks. Each task provides the current time, a DateTime object, for the state argument of the ContinueWith(Action<Task,Object>, Object) method. Each DateTime value represents the time at which the continue task is created. Each task produces as its result a second DateTime value that represents the time at which the task finishes. After all tasks finish, the example displays the date and times at which each continuation task starts and finishes.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Remarks

The returned Task<TResult> will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

See also

• Chaining Tasks by Using Continuation Tasks

Source:

Future.cs

Source:

Task_T.cs

Source:

Future.cs

Source:

Future.cs

Source:

Future.cs

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

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

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

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

Type Parameters

Parameters

Returns

A new continuation Task<TResult>.

Exceptions

Remarks

The returned Task<TResult> will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

See also

• Task Parallel Library (TPL)
• Task-based Asynchronous Programming
• Chaining Tasks by Using Continuation Tasks

Source:

Future.cs

Source:

Task_T.cs

Source:

Future.cs

Source:

Future.cs

Source:

Future.cs

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

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

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

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

Type Parameters

Parameters

Returns

A new continuation Task<TResult>.

Exceptions

Remarks

The returned Task<TResult> will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

See also

• TaskScheduler
• Task Parallel Library (TPL)
• Task-based Asynchronous Programming
• Chaining Tasks by Using Continuation Tasks