Task<TResult>.ContinueWith Méthode

Définition

Espace de noms:

System.Threading.Tasks

Assembly:

System.Runtime.dll

Crée une tâche de continuation qui s’exécute lorsqu’une autre tâche se termine.

Surcharges

ContinueWith(Action<Task<TResult>,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crée une continuation qui s'exécute quand la Task<TResult> cible se termine.
ContinueWith(Action<Task<TResult>,Object>, Object, TaskScheduler)	Crée une continuation qui s'exécute quand la Task<TResult> cible se termine.
ContinueWith(Action<Task<TResult>,Object>, Object, TaskContinuationOptions)	Crée une continuation qui s'exécute quand la Task<TResult> cible se termine.
ContinueWith(Action<Task<TResult>,Object>, Object, CancellationToken)	Crée une continuation qui s'exécute quand la Task<TResult> cible se termine.
ContinueWith(Action<Task<TResult>>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crée une continuation qui s'exécute en fonction de la condition spécifiée dans continuationOptions.
ContinueWith(Action<Task<TResult>>, TaskContinuationOptions)	Crée une continuation qui s'exécute en fonction de la condition spécifiée dans continuationOptions.
ContinueWith(Action<Task<TResult>>, CancellationToken)	Crée une continuation pouvant être annulée qui s’exécute de façon asynchrone quand la Task<TResult> cible se termine.
ContinueWith(Action<Task<TResult>,Object>, Object)	Crée une continuation à laquelle sont passées des informations d’état et qui s’exécute quand le Task<TResult> cible s’exécute.
ContinueWith(Action<Task<TResult>>)	Crée une continuation qui s’exécute de façon asynchrone quand la tâche cible se termine.
ContinueWith(Action<Task<TResult>>, TaskScheduler)	Crée une continuation qui s'exécute de façon asynchrone quand la Task<TResult> cible se termine.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crée une continuation qui s'exécute quand la Task<TResult> cible se termine.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crée une continuation qui s'exécute en fonction de la condition spécifiée dans continuationOptions.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, TaskScheduler)	Crée une continuation qui s'exécute quand la Task<TResult> cible se termine.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, CancellationToken)	Crée une continuation qui s'exécute quand la Task<TResult> cible se termine.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, TaskContinuationOptions)	Crée une continuation qui s'exécute quand la Task<TResult> cible se termine.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, TaskContinuationOptions)	Crée une continuation qui s'exécute en fonction de la condition spécifiée dans continuationOptions.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, CancellationToken)	Crée une continuation qui s'exécute de façon asynchrone quand la Task<TResult> cible se termine.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object)	Crée une continuation qui s'exécute quand la Task<TResult> cible se termine.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>)	Crée une continuation qui s'exécute de façon asynchrone quand la Task<TResult> cible se termine.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, TaskScheduler)	Crée une continuation qui s'exécute de façon asynchrone quand la Task<TResult> cible se termine.

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

Source:

Future.cs

Crée une continuation qui s'exécute quand la Task<TResult> cible se termine.

C#

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);

Paramètres

continuationAction

Action<Task<TResult>,Object>

Action à exécuter quand Task<TResult> se termine. Lors de l'exécution, la tâche achevée et l'objet d'état fourni par l'appelant sont passés au délégué sous la forme d'arguments.

state

Object

Objet représentant les données que l'action de continuation doit utiliser.

cancellationToken

CancellationToken

CancellationToken qui sera assigné à la nouvelle tâche de continuation.

continuationOptions

TaskContinuationOptions

Options applicables quand la continuation est planifiée et qui en régissent le comportement. Cela inclut des critères, tels que OnlyOnCanceled, ainsi que des options d'exécution, telles que ExecuteSynchronously.

scheduler

TaskScheduler

The TaskScheduler à associer à la tâche de continuation et à utiliser pour son exécution.

Retours

Task

Nouvelle Task de continuation.

Exceptions

ArgumentNullException

L'argument scheduler a la valeur null.

ArgumentOutOfRangeException

L'argument continuationOptions spécifie une valeur non valide pour TaskContinuationOptions.

ObjectDisposedException

Le CancellationToken fourni a déjà été supprimé.

Remarques

L’exécution retournée Task n’est pas planifiée tant que la tâche actuelle n’est pas terminée. Si les critères spécifiés par le continuationOptions paramètre ne sont pas remplis, la tâche de continuation est annulée au lieu d’être planifiée.

Voir aussi

• Chaînage des tâches à l’aide de tâches de continuation

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

Source:

Future.cs

Crée une continuation qui s'exécute quand la Task<TResult> cible se termine.

C#

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

Paramètres

continuationAction

Action<Task<TResult>,Object>

Action à exécuter quand Task<TResult> se termine. Lors de l'exécution, la tâche achevée et l'objet d'état fourni par l'appelant sont passés au délégué sous la forme d'arguments.

state

Object

Objet représentant les données que l'action de continuation doit utiliser.

scheduler

TaskScheduler

The TaskScheduler à associer à la tâche de continuation et à utiliser pour son exécution.

Retours

Task

Nouvelle Task de continuation.

Exceptions

ArgumentNullException

L'argument scheduler a la valeur null.

Remarques

L’exécution retournée Task n’est pas planifiée tant que la tâche en cours n’est pas terminée, qu’elle soit terminée en raison d’une exécution à l’achèvement réussie, d’une erreur due à une exception non prise en charge ou d’une sortie anticipée en raison de l’annulation.

Voir aussi

• Chaînage des tâches à l’aide de tâches de continuation

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

Source:

Future.cs

Crée une continuation qui s'exécute quand la Task<TResult> cible se termine.

C#

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

Paramètres

continuationAction

Action<Task<TResult>,Object>

Action à exécuter quand Task<TResult> se termine. Lors de l'exécution, la tâche achevée et l'objet d'état fourni par l'appelant sont passés au délégué sous la forme d'arguments.

state

Object

Objet représentant les données que l'action de continuation doit utiliser.

continuationOptions

TaskContinuationOptions

Options applicables quand la continuation est planifiée et qui en régissent le comportement. Cela inclut des critères, tels que OnlyOnCanceled, ainsi que des options d'exécution, telles que ExecuteSynchronously.

Retours

Task

Nouvelle Task de continuation.

Exceptions

ArgumentNullException

L'argument continuationAction a la valeur null.

ArgumentOutOfRangeException

L'argument continuationOptions spécifie une valeur non valide pour TaskContinuationOptions.

Remarques

L’exécution retournée Task n’est pas planifiée tant que la tâche actuelle n’est pas terminée. Si les critères de continuation spécifiés par le biais du continuationOptions paramètre ne sont pas remplis, la tâche de continuation est annulée au lieu d’être planifiée.

Voir aussi

• Chaînage des tâches à l’aide de tâches de continuation

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

Source:

Future.cs

Crée une continuation qui s'exécute quand la Task<TResult> cible se termine.

C#

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

Paramètres

continuationAction

Action<Task<TResult>,Object>

Action à exécuter quand Task<TResult> se termine. Lors de l'exécution, la tâche achevée et l'objet d'état fourni par l'appelant sont passés au délégué sous la forme d'arguments.

state

Object

Objet représentant les données que l'action de continuation doit utiliser.

cancellationToken

CancellationToken

CancellationToken qui sera assigné à la nouvelle tâche de continuation.

Retours

Task

Nouvelle Task de continuation.

Exceptions

ArgumentNullException

L'argument continuationAction a la valeur null.

ObjectDisposedException

Le CancellationToken fourni a déjà été supprimé.

Remarques

L’exécution retournée Task n’est pas planifiée tant que la tâche en cours n’est pas terminée, qu’elle soit terminée en raison d’une exécution à l’achèvement réussie, d’une erreur due à une exception non prise en charge ou d’une sortie anticipée en raison de l’annulation.

Voir aussi

• Chaînage des tâches à l’aide de tâches de continuation

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

Source:

Future.cs

Crée une continuation qui s'exécute en fonction de la condition spécifiée dans continuationOptions.

C#

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);

Paramètres

continuationAction

Action<Task<TResult>>

Action à exécuter selon la condition spécifiée dans continuationOptions. Quand elle est exécutée, la tâche achevée est passée au délégué en tant qu'argument.

cancellationToken

CancellationToken

CancellationToken qui sera assigné à la nouvelle tâche de continuation.

continuationOptions

TaskContinuationOptions

Options applicables quand la continuation est planifiée et qui en régissent le comportement. Cela inclut des critères, tels que OnlyOnCanceled, ainsi que des options d'exécution, telles que ExecuteSynchronously.

scheduler

TaskScheduler

The TaskScheduler à associer à la tâche de continuation et à utiliser pour son exécution.

Retours

Task

Nouvelle Task de continuation.

Exceptions

ObjectDisposedException

Task<TResult> a été supprimé.

- ou -

Le CancellationTokenSource qui a créé cancellationToken a déjà été supprimé.

ArgumentNullException

L'argument continuationAction a la valeur null.

- ou -

L'argument scheduler a la valeur null.

ArgumentOutOfRangeException

L'argument continuationOptions spécifie une valeur non valide pour TaskContinuationOptions.

Remarques

L’exécution retournée Task n’est pas planifiée tant que la tâche actuelle n’est pas terminée. Si les critères spécifiés par le continuationOptions paramètre ne sont pas remplis, la tâche de continuation est annulée au lieu d’être planifiée. Pour plus d’informations, consultez Chaînage des tâches à l’aide de tâches de continuation.

Voir aussi

• Bibliothèque parallèle de tâches
• Programmation asynchrone basée sur les tâches
• Chaînage des tâches à l’aide de tâches de continuation

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

Source:

Future.cs

Crée une continuation qui s'exécute en fonction de la condition spécifiée dans continuationOptions.

C#

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

Paramètres

continuationAction

Action<Task<TResult>>

Action à exécuter selon la condition spécifiée dans continuationOptions. Quand elle est exécutée, la tâche achevée est passée au délégué en tant qu'argument.

continuationOptions

TaskContinuationOptions

Options applicables quand la continuation est planifiée et qui en régissent le comportement. Cela inclut des critères, tels que OnlyOnCanceled, ainsi que des options d'exécution, telles que ExecuteSynchronously.

Retours

Task

Nouvelle Task de continuation.

Exceptions

ObjectDisposedException

Task<TResult> a été supprimé.

ArgumentNullException

L'argument continuationAction a la valeur null.

ArgumentOutOfRangeException

L'argument continuationOptions spécifie une valeur non valide pour TaskContinuationOptions.

Remarques

L’exécution retournée Task n’est pas planifiée tant que la tâche actuelle n’est pas terminée. Si les critères de continuation spécifiés par le biais du continuationOptions paramètre ne sont pas remplis, la tâche de continuation est annulée au lieu d’être planifiée.

Pour plus d’informations, consultez Chaînage des tâches à l’aide de tâches de continuation.

Voir aussi

• Bibliothèque parallèle de tâches
• Programmation asynchrone basée sur les tâches
• Chaînage des tâches à l’aide de tâches de continuation

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

Source:

Future.cs

Crée une continuation pouvant être annulée qui s’exécute de façon asynchrone quand la Task<TResult> cible se termine.

C#

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

Paramètres

continuationAction

Action<Task<TResult>>

Action à exécuter quand Task<TResult> se termine. Quand elle est exécutée, la tâche achevée est passée au délégué en tant qu’argument.

cancellationToken

CancellationToken

Jeton d’annulation passé à la nouvelle tâche de continuation.

Retours

Task

Nouvelle tâche de continuation.

Exceptions

ObjectDisposedException

Task<TResult> a été supprimé.

- ou -

Le CancellationTokenSource qui a créé cancellationToken a été supprimé.

ArgumentNullException

L'argument continuationAction a la valeur null.

Exemples

L’exemple suivant crée une tâche antérieure qui utilise le tamis d’Eratosthènes pour calculer les nombres premiers compris entre 1 et une valeur entrée par l’utilisateur. Un tableau est utilisé pour contenir des informations sur les nombres premiers. L’index de tableau représente le nombre, et la valeur de l’élément indique si ce nombre est composite (sa valeur est true) ou premier (sa valeur est false). Cette tâche est ensuite passée à une tâche de continuation, qui est chargée d’extraire les nombres premiers du tableau d’entiers et de les afficher.

Un jeton d’annulation est passé à l’antécédent et à la tâche de continuation. Un System.Timers.Timer objet est utilisé pour définir une valeur de délai d’expiration de 100 millisecondes. Si l’événement se déclenche, la CancellationTokenSource.Cancel méthode est appelée et le jeton d’annulation est utilisé pour demander l’annulation des tâches.

C#

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

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

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

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

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

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

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

En règle générale, la fourniture d’une valeur d’environ 100 000 entraîne l’expiration de l’intervalle d’expiration et le déclenchement de l’événement Timer.Elapsed , ainsi que la demande d’annulation à définir.

Remarques

L’exécution retournée Task n’est pas planifiée tant que la tâche en cours n’est pas terminée, qu’elle soit terminée en raison d’une exécution à l’achèvement réussie, d’une erreur due à une exception non prise en charge ou d’une sortie anticipée en raison de l’annulation.

Voir aussi

• Bibliothèque parallèle de tâches
• Programmation asynchrone basée sur les tâches
• Chaînage des tâches à l’aide de tâches de continuation

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

Source:

Future.cs

Crée une continuation à laquelle sont passées des informations d’état et qui s’exécute quand le Task<TResult> cible s’exécute.

C#

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

Paramètres

continuationAction

Action<Task<TResult>,Object>

Action à exécuter quand Task<TResult> se termine. Lors de l’exécution, le délégué reçoit la tâche terminée et l’objet d’état fourni par l’appelant en tant qu’arguments.

state

Object

Objet représentant les données que l'action de continuation doit utiliser.

Retours

Task

Nouvelle Task de continuation.

Exceptions

ArgumentNullException

L'argument continuationAction a la valeur null.

Exemples

L’exemple suivant crée une tâche qui reçoit un entier compris entre 2 et 20 et retourne un tableau qui contient les dix premiers exposants (de n¹ à n¹⁰) de ce nombre. Une tâche de continuation est ensuite chargée d’afficher les exposants. Il est passé à la fois l’antécédent et le nombre d’origine dont l’exposant génère l’antécédent.

C#

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

Remarques

L’exécution retournée Task n’est pas planifiée tant que la tâche en cours n’est pas terminée, qu’elle soit terminée en raison d’une exécution à l’achèvement réussie, d’une erreur due à une exception non prise en charge ou d’une sortie anticipée en raison de l’annulation.

Voir aussi

• Chaînage des tâches à l’aide de tâches de continuation

ContinueWith(Action<Task<TResult>>)

Source:

Future.cs

Crée une continuation qui s’exécute de façon asynchrone quand la tâche cible se termine.

C#

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

Paramètres

continuationAction

Action<Task<TResult>>

Action à exécuter quand la Task<TResult> antécédente se termine. Quand elle est exécutée, la tâche achevée est passée au délégué en tant qu'argument.

Retours

Task

Nouvelle tâche de continuation.

Exceptions

ObjectDisposedException

Task<TResult> a été supprimé.

ArgumentNullException

L'argument continuationAction a la valeur null.

Exemples

L’exemple suivant crée une tâche antérieure qui utilise le tamis d’Eratosthènes pour calculer les nombres premiers compris entre 1 et une valeur entrée par l’utilisateur. Un tableau est utilisé pour contenir des informations sur les nombres premiers. L’index de tableau représente le nombre, et la valeur de l’élément indique si ce nombre est composite (sa valeur est true) ou premier (sa valeur est false). Cette tâche est ensuite passée à une tâche de continuation, qui est chargée d’extraire les nombres premiers du tableau d’entiers et de les afficher.

C#

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

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

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

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

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

Remarques

L’exécution retournée Task n’est pas planifiée tant que la tâche en cours n’est pas terminée, qu’elle soit terminée en raison d’une exécution réussie, d’une erreur en raison d’une exception non prise en charge ou d’une sortie anticipée en raison de l’annulation.

Voir aussi

• Bibliothèque parallèle de tâches
• Programmation asynchrone basée sur les tâches
• Chaînage des tâches à l’aide de tâches de continuation

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

Source:

Future.cs

Crée une continuation qui s'exécute de façon asynchrone quand la Task<TResult> cible se termine.

C#

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

Paramètres

continuationAction

Action<Task<TResult>>

Action à exécuter quand Task<TResult> se termine. Quand elle est exécutée, la tâche achevée est passée au délégué en tant qu'argument.

scheduler

TaskScheduler

The TaskScheduler à associer à la tâche de continuation et à utiliser pour son exécution.

Retours

Task

Nouvelle Task de continuation.

Exceptions

ObjectDisposedException

Task<TResult> a été supprimé.

ArgumentNullException

L'argument continuationAction a la valeur null.

- ou -

L'argument scheduler a la valeur null.

Remarques

L’exécution retournée Task n’est pas planifiée tant que la tâche en cours n’est pas terminée, qu’elle soit terminée en raison d’une exécution à l’achèvement réussie, d’une erreur due à une exception non prise en charge ou d’une sortie anticipée en raison de l’annulation.

Voir aussi

• Bibliothèque parallèle de tâches
• Programmation asynchrone basée sur les tâches
• Chaînage des tâches à l’aide de tâches de continuation

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

Source:

Future.cs

Crée une continuation qui s'exécute quand la Task<TResult> cible se termine.

C#

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);

Paramètres de type

TNewResult

Type du résultat produit par la continuation.

Paramètres

continuationFunction

Func<Task<TResult>,Object,TNewResult>

Fonction à exécuter quand Task<TResult> se termine. Lors de l'exécution, la tâche achevée et l'objet d'état fourni par l'appelant sont passés au délégué sous la forme d'arguments.

state

Object

Objet représentant les données que la fonction de continuation doit utiliser.

cancellationToken

CancellationToken

CancellationToken qui sera assigné à la nouvelle tâche.

continuationOptions

TaskContinuationOptions

Options applicables quand la continuation est planifiée et qui en régissent le comportement. Cela inclut des critères, tels que OnlyOnCanceled, ainsi que des options d'exécution, telles que ExecuteSynchronously.

scheduler

TaskScheduler

The TaskScheduler à associer à la tâche de continuation et à utiliser pour son exécution.

Retours

Task<TNewResult>

Nouvelle Task<TResult> de continuation.

Exceptions

ArgumentNullException

L'argument scheduler a la valeur null.

ArgumentOutOfRangeException

L'argument continuationOptions spécifie une valeur non valide pour TaskContinuationOptions.

ObjectDisposedException

Le CancellationToken fourni a déjà été supprimé.

Remarques

L’exécution retournée Task<TResult> n’est pas planifiée tant que la tâche en cours n’est pas terminée, qu’elle soit terminée en raison d’une exécution à l’achèvement réussie, d’une erreur due à une exception non prise en charge ou d’une sortie anticipée en raison de l’annulation.

Le continuationFunction, lorsqu’il est exécuté, doit retourner un Task<TResult>. L’état d’achèvement de cette tâche est transféré vers la tâche retournée à partir de l’appel Task<TResult>.ContinueWith .

Voir aussi

• Chaînage des tâches à l’aide de tâches de continuation

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

Source:

Future.cs

Crée une continuation qui s'exécute en fonction de la condition spécifiée dans continuationOptions.

C#

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);

Paramètres de type

TNewResult

Type du résultat produit par la continuation.

Paramètres

continuationFunction

Func<Task<TResult>,TNewResult>

Fonction à exécuter selon la condition spécifiée dans continuationOptions.

Une fois exécuté, le délégué passera cette tâche achevée en tant qu'argument.

cancellationToken

CancellationToken

CancellationToken qui sera assigné à la nouvelle tâche.

continuationOptions

TaskContinuationOptions

Options applicables quand la continuation est planifiée et qui en régissent le comportement. Cela inclut des critères, tels que OnlyOnCanceled, ainsi que des options d'exécution, telles que ExecuteSynchronously.

scheduler

TaskScheduler

The TaskScheduler à associer à la tâche de continuation et à utiliser pour son exécution.

Retours

Task<TNewResult>

Nouvelle Task<TResult> de continuation.

Exceptions

ObjectDisposedException

Task<TResult> a été supprimé.

- ou -

Le CancellationTokenSource qui a créé cancellationToken a déjà été supprimé.

ArgumentNullException

L'argument continuationFunction a la valeur null.

- ou -

L'argument scheduler a la valeur null.

ArgumentOutOfRangeException

L'argument continuationOptions spécifie une valeur non valide pour TaskContinuationOptions.

Remarques

L’exécution retournée Task<TResult> n’est pas planifiée tant que la tâche en cours n’est pas terminée, qu’elle soit terminée en raison d’une exécution réussie, d’une erreur due à une exception non gérée ou d’une fermeture anticipée en raison d’une annulation.

Le continuationFunction, lorsqu’il est exécuté, doit retourner un Task<TResult>.

Voir aussi

• Bibliothèque parallèle de tâches
• Programmation asynchrone basée sur les tâches
• Chaînage des tâches à l’aide de tâches de continuation

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

Source:

Future.cs

Crée une continuation qui s'exécute quand la Task<TResult> cible se termine.

C#

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

Paramètres de type

TNewResult

Type du résultat produit par la continuation.

Paramètres

continuationFunction

Func<Task<TResult>,Object,TNewResult>

Fonction à exécuter quand Task<TResult> se termine. Lors de l'exécution, la tâche achevée et l'objet d'état fourni par l'appelant sont passés au délégué sous la forme d'arguments.

state

Object

Objet représentant les données que la fonction de continuation doit utiliser.

scheduler

TaskScheduler

The TaskScheduler à associer à la tâche de continuation et à utiliser pour son exécution.

Retours

Task<TNewResult>

Nouvelle Task<TResult> de continuation.

Exceptions

ArgumentNullException

L'argument scheduler a la valeur null.

Remarques

L’exécution retournée Task<TResult> n’est pas planifiée tant que la tâche en cours n’est pas terminée, qu’elle soit terminée en raison d’une exécution réussie, d’une erreur due à une exception non gérée ou d’une fermeture anticipée en raison d’une annulation.

Voir aussi

• Chaînage des tâches à l’aide de tâches de continuation

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

Source:

Future.cs

Crée une continuation qui s'exécute quand la Task<TResult> cible se termine.

C#

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

Paramètres de type

TNewResult

Type du résultat produit par la continuation.

Paramètres

continuationFunction

Func<Task<TResult>,Object,TNewResult>

Fonction à exécuter quand Task<TResult> se termine. Lors de l'exécution, la tâche achevée et l'objet d'état fourni par l'appelant sont passés au délégué sous la forme d'arguments.

state

Object

Objet représentant les données que la fonction de continuation doit utiliser.

cancellationToken

CancellationToken

CancellationToken qui sera assigné à la nouvelle tâche.

Retours

Task<TNewResult>

Nouvelle Task<TResult> de continuation.

Exceptions

ArgumentNullException

L'argument continuationFunction a la valeur null.

ObjectDisposedException

Le CancellationToken fourni a déjà été supprimé.

Remarques

L’exécution retournée Task<TResult> n’est pas planifiée tant que la tâche en cours n’est pas terminée, qu’elle soit terminée en raison d’une exécution réussie, d’une erreur due à une exception non gérée ou d’une fermeture anticipée en raison d’une annulation.

Voir aussi

• Chaînage des tâches à l’aide de tâches de continuation

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

Source:

Future.cs

Crée une continuation qui s'exécute quand la Task<TResult> cible se termine.

C#

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

Paramètres de type

TNewResult

Type du résultat produit par la continuation.

Paramètres

continuationFunction

Func<Task<TResult>,Object,TNewResult>

Fonction à exécuter quand Task<TResult> se termine. Lors de l'exécution, la tâche achevée et l'objet d'état fourni par l'appelant sont passés au délégué sous la forme d'arguments.

state

Object

Objet représentant les données que la fonction de continuation doit utiliser.

continuationOptions

TaskContinuationOptions

Options applicables quand la continuation est planifiée et qui en régissent le comportement. Cela inclut des critères, tels que OnlyOnCanceled, ainsi que des options d'exécution, telles que ExecuteSynchronously.

Retours

Task<TNewResult>

Nouvelle Task<TResult> de continuation.

Exceptions

ArgumentNullException

L'argument continuationFunction a la valeur null.

ArgumentOutOfRangeException

L'argument continuationOptions spécifie une valeur non valide pour TaskContinuationOptions.

Remarques

L’exécution retournée Task<TResult> n’est pas planifiée tant que la tâche en cours n’est pas terminée, qu’elle soit terminée en raison d’une exécution réussie, d’une erreur due à une exception non gérée ou d’une fermeture anticipée en raison d’une annulation.

Le continuationFunction, lorsqu’il est exécuté, doit retourner un Task<TResult>. L’état d’achèvement de cette tâche est transféré à la tâche retournée à partir de l’appel ContinueWith.

Voir aussi

• Chaînage des tâches à l’aide de tâches de continuation

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

Source:

Future.cs

Crée une continuation qui s'exécute en fonction de la condition spécifiée dans continuationOptions.

C#

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

Paramètres de type

TNewResult

Type du résultat produit par la continuation.

Paramètres

continuationFunction

Func<Task<TResult>,TNewResult>

Fonction à exécuter selon la condition spécifiée dans continuationOptions.

Quand elle est exécutée, la tâche achevée est passée au délégué en tant qu'argument.

continuationOptions

TaskContinuationOptions

Options applicables quand la continuation est planifiée et qui en régissent le comportement. Cela inclut des critères, tels que OnlyOnCanceled, ainsi que des options d'exécution, telles que ExecuteSynchronously.

Retours

Task<TNewResult>

Nouvelle Task<TResult> de continuation.

Exceptions

ObjectDisposedException

Task<TResult> a été supprimé.

ArgumentNullException

L'argument continuationFunction a la valeur null.

ArgumentOutOfRangeException

L'argument continuationOptions spécifie une valeur non valide pour TaskContinuationOptions.

Remarques

L’exécution retournée Task<TResult> n’est pas planifiée tant que la tâche en cours n’est pas terminée, qu’elle soit terminée en raison d’une exécution réussie, d’une erreur due à une exception non gérée ou d’une fermeture anticipée en raison d’une annulation.

Le continuationFunction, lorsqu’il est exécuté, doit retourner un Task<TResult>.

Voir aussi

• Bibliothèque parallèle de tâches
• Programmation asynchrone basée sur les tâches
• Chaînage des tâches à l’aide de tâches de continuation

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

Source:

Future.cs

Crée une continuation qui s'exécute de façon asynchrone quand la Task<TResult> cible se termine.

C#

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

Paramètres de type

TNewResult

Type du résultat produit par la continuation.

Paramètres

continuationFunction

Func<Task<TResult>,TNewResult>

Fonction à exécuter quand Task<TResult> se termine. Quand elle est exécutée, la tâche achevée est passée au délégué en tant qu'argument.

cancellationToken

CancellationToken

CancellationToken qui sera assigné à la nouvelle tâche.

Retours

Task<TNewResult>

Nouvelle Task<TResult> de continuation.

Exceptions

ObjectDisposedException

Task<TResult> a été supprimé.

- ou -

Le CancellationTokenSource qui a créé cancellationToken a déjà été supprimé.

ArgumentNullException

L'argument continuationFunction a la valeur null.

Remarques

L’exécution retournée Task<TResult> n’est pas planifiée tant que la tâche en cours n’est pas terminée, qu’elle soit terminée en raison d’une exécution réussie, d’une erreur due à une exception non gérée ou d’une fermeture anticipée en raison d’une annulation.

Voir aussi

• Bibliothèque parallèle de tâches
• Programmation asynchrone basée sur les tâches
• Chaînage des tâches à l’aide de tâches de continuation

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

Source:

Future.cs

Crée une continuation qui s'exécute quand la Task<TResult> cible se termine.

C#

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

Paramètres de type

TNewResult

Type du résultat produit par la continuation.

Paramètres

continuationFunction

Func<Task<TResult>,Object,TNewResult>

Fonction à exécuter quand Task<TResult> se termine. Lors de l'exécution, la tâche achevée et l'objet d'état fourni par l'appelant sont passés au délégué sous la forme d'arguments.

state

Object

Objet représentant les données que la fonction de continuation doit utiliser.

Retours

Task<TNewResult>

Nouvelle Task<TResult> de continuation.

Exceptions

ArgumentNullException

L'argument continuationFunction a la valeur null.

Exemples

L’exemple suivant crée une chaîne de tâches de continuation. Chaque tâche fournit l’heure actuelle, un DateTime objet, pour l’argument d’état de la ContinueWith(Action<Task,Object>, Object) méthode. Chaque DateTime valeur représente l’heure à laquelle la tâche continue est créée. Chaque tâche produit comme résultat une deuxième DateTime valeur qui représente l’heure à laquelle la tâche se termine. Une fois toutes les tâches terminées, l’exemple affiche la date et l’heure auxquelles chaque tâche de continuation démarre et se termine.

C#

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.
*/

Remarques

L’exécution retournée Task<TResult> n’est pas planifiée tant que la tâche en cours n’est pas terminée, qu’elle soit terminée en raison d’une exécution réussie, d’une erreur due à une exception non gérée ou d’une fermeture anticipée en raison d’une annulation.

Voir aussi

• Chaînage des tâches à l’aide de tâches de continuation

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

Source:

Future.cs

Crée une continuation qui s'exécute de façon asynchrone quand la Task<TResult> cible se termine.

C#

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

Paramètres de type

TNewResult

Type du résultat produit par la continuation.

Paramètres

continuationFunction

Func<Task<TResult>,TNewResult>

Fonction à exécuter quand Task<TResult> se termine. Quand elle est exécutée, la tâche achevée est passée au délégué en tant qu'argument.

Retours

Task<TNewResult>

Nouvelle Task<TResult> de continuation.

Exceptions

ObjectDisposedException

Task<TResult> a été supprimé.

ArgumentNullException

L'argument continuationFunction a la valeur null.

Remarques

L’exécution retournée Task<TResult> n’est pas planifiée tant que la tâche en cours n’est pas terminée, qu’elle soit terminée en raison d’une exécution réussie, d’une erreur due à une exception non gérée ou d’une fermeture anticipée en raison d’une annulation.

Voir aussi

• Bibliothèque parallèle de tâches
• Programmation asynchrone basée sur les tâches
• Chaînage des tâches à l’aide de tâches de continuation

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

Source:

Future.cs

Crée une continuation qui s'exécute de façon asynchrone quand la Task<TResult> cible se termine.

C#

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

Paramètres de type

TNewResult

Type du résultat produit par la continuation.

Paramètres

continuationFunction

Func<Task<TResult>,TNewResult>

Fonction à exécuter quand Task<TResult> se termine. Quand elle est exécutée, la tâche achevée est passée au délégué en tant qu'argument.

scheduler

TaskScheduler

The TaskScheduler à associer à la tâche de continuation et à utiliser pour son exécution.

Retours

Task<TNewResult>

Nouvelle Task<TResult> de continuation.

Exceptions

ObjectDisposedException

Task<TResult> a été supprimé.

ArgumentNullException

L'argument continuationFunction a la valeur null.

- ou -

L'argument scheduler a la valeur null.

Remarques

L’exécution retournée Task<TResult> n’est pas planifiée tant que la tâche en cours n’est pas terminée, qu’elle soit terminée en raison d’une exécution réussie, d’une erreur due à une exception non gérée ou d’une fermeture anticipée en raison d’une annulation.

Voir aussi

• TaskScheduler
• Bibliothèque parallèle de tâches
• Programmation asynchrone basée sur les tâches
• Chaînage des tâches à l’aide de tâches de continuation