Task.ContinueWith Méthode

Référence

Définition

Espace de noms:: System.Threading.Tasks

Assembly:: System.Threading.Tasks.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

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

Surcharges

ContinueWith(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crée une continuation qui reçoit des informations d'état fournies par l'appelant et un jeton d'annulation, et qui s'exécute quand le Task cible se termine. La continuation s'exécute selon un ensemble de conditions spécifiées et utilise un planificateur spécifié.
ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crée une continuation qui s’exécute quand la tâche cible se termine conformément au TaskContinuationOptions spécifié. La continuation reçoit un jeton d'annulation et utilise un planificateur spécifié.
ContinueWith(Action<Task,Object>, Object, TaskScheduler)	Crée une continuation qui reçoit des informations d'état fournies par l'appelant et s'exécute de façon asynchrone quand le Task cible se termine. La continuation utilise un planificateur spécifié.
ContinueWith(Action<Task,Object>, Object, TaskContinuationOptions)	Crée une continuation qui reçoit des informations d'état fournies par l'appelant et s'exécute quand le Task cible se termine. La continuation s'exécute selon un ensemble de conditions spécifiées.
ContinueWith(Action<Task,Object>, Object, CancellationToken)	Crée une continuation qui reçoit des informations d'état fournies par l'appelant et un jeton d'annulation, et qui s'exécute de façon asynchrone quand le Task cible se termine.
ContinueWith(Action<Task>)	Crée une continuation qui s'exécute de façon asynchrone quand la Task cible se termine.
ContinueWith(Action<Task>, TaskContinuationOptions)	Crée une continuation qui s’exécute quand la tâche cible se termine conformément au TaskContinuationOptions spécifié.
ContinueWith(Action<Task>, CancellationToken)	Crée une continuation qui reçoit un jeton d'annulation et s'exécute de façon asynchrone quand le Task cible se termine.
ContinueWith(Action<Task,Object>, Object)	Crée une continuation qui reçoit des informations d'état fournies par l'appelant et s'exécute quand le Task cible se termine.
ContinueWith(Action<Task>, TaskScheduler)	Crée une continuation qui s'exécute de façon asynchrone quand la Task cible se termine. La continuation utilise un planificateur spécifié.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskScheduler)	Crée une continuation qui s'exécute de façon asynchrone quand la Task cible se termine. La continuation reçoit des informations d'état fournies par l'appelant et utilise un planificateur spécifié.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crée une continuation qui s’exécute en fonction des options de continuation de tâche spécifiées quand le Task cible se termine et retourne une valeur. La continuation reçoit des informations d'état fournies par l'appelant et un jeton d'annulation et elle utilise un planificateur spécifié.
ContinueWith<TResult>(Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crée une continuation qui s'exécute en fonction des options de continuation spécifiées et retourne une valeur. La continuation reçoit un jeton d'annulation et utilise un planificateur spécifié.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken)	Crée une continuation qui s'exécute de façon asynchrone quand le Task cible se termine et retourne une valeur. La continuation reçoit des informations d'état fournies par l'appelant et un jeton d'annulation.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskContinuationOptions)	Crée une continuation qui s’exécute en fonction des options de continuation de tâche spécifiées quand le Task cible se termine. La continuation reçoit des informations d'état fournies par l'appelant.
ContinueWith<TResult>(Func<Task,TResult>, TaskContinuationOptions)	Crée une continuation qui s'exécute en fonction des options de continuation spécifiées et retourne une valeur.
ContinueWith<TResult>(Func<Task,TResult>, TaskScheduler)	Crée une continuation qui s'exécute de façon asynchrone quand le Task cible se termine et retourne une valeur. La continuation utilise un planificateur spécifié.
ContinueWith<TResult>(Func<Task,TResult>, CancellationToken)	Crée une continuation qui s'exécute de façon asynchrone quand le Task cible se termine et retourne une valeur. La continuation reçoit un jeton d'annulation.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object)	Crée une continuation qui reçoit des informations d'état fournies par l'appelant et s'exécute de façon asynchrone quand le Task cible se termine et retourne une valeur.
ContinueWith<TResult>(Func<Task,TResult>)	Crée une continuation qui s'exécute de façon asynchrone quand le Task<TResult> cible se termine et retourne une valeur.

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Crée une continuation qui reçoit des informations d'état fournies par l'appelant et un jeton d'annulation, et qui s'exécute quand le Task cible se termine. La continuation s'exécute selon un ensemble de conditions spécifiées et utilise un planificateur spécifié.

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

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

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

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

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

Paramètres

continuationAction: Action<Task,Object>

Action à exécuter quand Task 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 via le continuationOptions paramètre ne sont pas remplis, la tâche de continuation est annulée au lieu de planifiée.

S’applique à

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Crée une continuation qui s’exécute quand la tâche cible se termine conformément au TaskContinuationOptions spécifié. La continuation reçoit un jeton d'annulation et utilise un planificateur spécifié.

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

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

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

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

Paramètres

continuationAction: Action<Task>

Action à exécuter selon le continuationOptionsspécifié. 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

scheduler: TaskScheduler

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

Retours

Task

Nouvelle Task de continuation.

Exceptions

ObjectDisposedException

Le CancellationTokenSource qui a créé le jeton 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.

Exemples

Voici un exemple d’utilisation de ContinueWith pour exécuter du travail à la fois en arrière-plan et sur les threads d’interface utilisateur.

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

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

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

Remarques

S’applique à

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Crée une continuation qui reçoit des informations d'état fournies par l'appelant et s'exécute de façon asynchrone quand le Task cible se termine. La continuation utilise un planificateur spécifié.

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

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

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

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

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

Paramètres

continuationAction: Action<Task,Object>

Action à exécuter quand Task 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 réussie, d’une erreur due à une exception non gérée ou d’une fermeture anticipée en raison d’une annulation.

S’applique à

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Crée une continuation qui reçoit des informations d'état fournies par l'appelant et s'exécute quand le Task cible se termine. La continuation s'exécute selon un ensemble de conditions spécifiées.

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

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

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

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

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

Paramètres

continuationAction: Action<Task,Object>

Action à exécuter quand Task 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

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 via le continuationOptions paramètre ne sont pas remplis, la tâche de continuation est annulée au lieu de planifiée.

S’applique à

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Crée une continuation qui reçoit des informations d'état fournies par l'appelant et un jeton d'annulation, et qui s'exécute de façon asynchrone quand le Task cible se termine.

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

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

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

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

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

Paramètres

continuationAction: Action<Task,Object>

Action à exécuter quand Task 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

S’applique à

ContinueWith(Action<Task>)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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

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

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

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

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

Paramètres

continuationAction: Action<Task>

Action à exécuter quand Task 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 Task de continuation.

Exceptions

ArgumentNullException

L'argument continuationAction a la valeur null.

Exemples

L’exemple suivant définit une tâche qui remplit un tableau avec 100 valeurs de date et d’heure aléatoires. Elle utilise la ContinueWith(Action<Task>) méthode pour sélectionner les valeurs de date les plus anciennes et les plus récentes une fois que le tableau est entièrement rempli.

using System;
using System.Threading.Tasks;

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

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

open System
open System.Threading.Tasks

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

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

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

        dates)

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

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

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

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


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

Imports System.Threading.Tasks

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

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

Étant donné qu’une application console peut se terminer avant l’exécution de la tâche de continuation, la Wait() méthode est appelée pour s’assurer que l’exécution de la continuation se termine avant la fin de l’exemple.

Pour obtenir un exemple supplémentaire, consultez Chaînage de tâches à l’aide de tâches de continuation.

Remarques

S’applique à

ContinueWith(Action<Task>, TaskContinuationOptions)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Crée une continuation qui s’exécute quand la tâche cible se termine conformément au TaskContinuationOptions spécifié.

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

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

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

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

Paramètres

continuationAction: Action<Task>

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

continuationOptions: TaskContinuationOptions

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.

Exemples

L’exemple suivant illustre l’utilisation TaskContinuationOptions de pour spécifier qu’une tâche de continuation doit s’exécuter de manière synchrone lorsque la tâche antérieure se termine. (Si la tâche spécifiée est déjà terminée au moment ContinueWith de l’appel, la continuation synchrone s’exécute sur le thread appelant ContinueWith.)

public class TaskCounter
{
   private volatile int _count;

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

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

Public Class TaskCounter
   Private _count as Integer

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

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

Remarques

S’applique à

ContinueWith(Action<Task>, CancellationToken)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Crée une continuation qui reçoit un jeton d'annulation et s'exécute de façon asynchrone quand le Task cible se termine.

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

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

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

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

Paramètres

continuationAction: Action<Task>

Action à exécuter quand Task 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 de continuation.

Retours

Task

Nouvelle Task de continuation.

Exceptions

ObjectDisposedException

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

ArgumentNullException

L’argument continuationAction a la valeur null.

Remarques

S’applique à

ContinueWith(Action<Task,Object>, Object)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Crée une continuation qui reçoit des informations d'état fournies par l'appelant et s'exécute quand le Task cible se termine.

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

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

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

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

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

Paramètres

continuationAction: Action<Task,Object>

Action à exécuter quand la tâche se termine. Lors de l’exécution, la tâche achevée et l’objet d’état fourni par l’appelant sont passés comme arguments au délégué.

state: Object

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

Retours

Task

Nouvelle tâche de continuation.

Exceptions

ArgumentNullException

L'argument continuationAction a la valeur null.

Remarques

L’exécution retournée Task n’est pas planifiée tant que la tâche actuelle n’est pas terminée, qu’elle se termine 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.

S’applique à

ContinueWith(Action<Task>, TaskScheduler)

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Crée une continuation qui s'exécute de façon asynchrone quand la Task cible se termine. La continuation utilise un planificateur spécifié.

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

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

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

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

Paramètres

continuationAction: Action<Task>

Action à exécuter quand Task 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 a été supprimé.

ArgumentNullException

L'argument continuationAction a la valeur null.

- ou -

L’argument scheduler a la valeur null.

Remarques

S’applique à

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Crée une continuation qui s'exécute de façon asynchrone quand la Task cible se termine. La continuation reçoit des informations d'état fournies par l'appelant et utilise un planificateur spécifié.

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

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

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

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

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

Paramètres de type

TResult

Type du résultat produit par la continuation.

Paramètres

continuationFunction: Func<Task,Object,TResult>

Fonction à exécuter quand Task 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<TResult>

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.

S’applique à

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Crée une continuation qui s’exécute en fonction des options de continuation de tâche spécifiées quand le Task cible se termine et retourne une valeur. La continuation reçoit des informations d'état fournies par l'appelant et un jeton d'annulation et elle utilise un planificateur spécifié.

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

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

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

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

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

Paramètres de type

TResult

Type du résultat produit par la continuation.

Paramètres

continuationFunction: Func<Task,Object,TResult>

Fonction à exécuter quand Task 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 de continuation.

continuationOptions: TaskContinuationOptions

scheduler: TaskScheduler

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

Retours

Task<TResult>

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

S’applique à

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Crée une continuation qui s'exécute en fonction des options de continuation spécifiées et retourne une valeur. La continuation reçoit un jeton d'annulation et utilise un planificateur spécifié.

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

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

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

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

Paramètres de type

TResult

Type du résultat produit par la continuation.

Paramètres

continuationFunction: Func<Task,TResult>

Fonction à exécuter en fonction du spécifié continuationOptions. Lors de l’exécution, le délégué passe la tâche terminée en tant qu’argument.

cancellationToken: CancellationToken

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

continuationOptions: TaskContinuationOptions

scheduler: TaskScheduler

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

Retours

Task<TResult>

Nouvelle Task<TResult> de continuation.

Exceptions

ObjectDisposedException

Task a été supprimé.

- ou -

Le CancellationTokenSource qui a créé le jeton 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.

Exemples

L’exemple suivant montre comment utiliser la méthode ContinueWith avec les options de continuation :

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

let failure =
    fun () ->

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

        raise (InvalidOperationException "SIMULATED EXCEPTION")

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

let rollback =
    fun (antecendent: Task) ->

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

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

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

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

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

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

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

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

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

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

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

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

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

Imports System.Threading
Imports System.Threading.Tasks

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

Remarques

S’applique à

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Crée une continuation qui s'exécute de façon asynchrone quand le Task cible se termine et retourne une valeur. La continuation reçoit des informations d'état fournies par l'appelant et un jeton d'annulation.

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

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

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

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

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

Paramètres de type

TResult

Type du résultat produit par la continuation.

Paramètres

continuationFunction: Func<Task,Object,TResult>

Fonction à exécuter quand Task 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 de continuation.

Retours

Task<TResult>

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 à 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.

S’applique à

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Crée une continuation qui s’exécute en fonction des options de continuation de tâche spécifiées quand le Task cible se termine. La continuation reçoit des informations d'état fournies par l'appelant.

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

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

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

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

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

Paramètres de type

TResult

Type du résultat produit par la continuation.

Paramètres

continuationFunction: Func<Task,Object,TResult>

Fonction à exécuter quand Task 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

Retours

Task<TResult>

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

S’applique à

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Crée une continuation qui s'exécute en fonction des options de continuation spécifiées et retourne une valeur.

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

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

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

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

Paramètres de type

TResult

Type du résultat produit par la continuation.

Paramètres

continuationFunction: Func<Task,TResult>

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

Retours

Task<TResult>

Nouvelle Task<TResult> de continuation.

Exceptions

ObjectDisposedException

Task a été supprimé.

ArgumentNullException

L’argument continuationFunction a la valeur null.

ArgumentOutOfRangeException

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

Remarques

S’applique à

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Crée une continuation qui s'exécute de façon asynchrone quand le Task cible se termine et retourne une valeur. La continuation utilise un planificateur spécifié.

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

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

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

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

Paramètres de type

TResult

Type du résultat produit par la continuation.

Paramètres

continuationFunction: Func<Task,TResult>

Fonction à exécuter quand Task 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<TResult>

Nouvelle Task<TResult> de continuation.

Exceptions

ObjectDisposedException

Task a été supprimé.

ArgumentNullException

L’argument continuationFunction a la valeur null.

- ou -

L’argument scheduler a la valeur null.

Remarques

S’applique à

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Crée une continuation qui s'exécute de façon asynchrone quand le Task cible se termine et retourne une valeur. La continuation reçoit un jeton d'annulation.

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

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

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

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

Paramètres de type

TResult

Type du résultat produit par la continuation.

Paramètres

continuationFunction: Func<Task,TResult>

Fonction à exécuter quand Task 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 de continuation.

Retours

Task<TResult>

Nouvelle Task<TResult> de continuation.

Exceptions

ObjectDisposedException

Task a été supprimé.

- ou -

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

ArgumentNullException

L’argument continuationFunction a la valeur null.

Remarques

S’applique à

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Crée une continuation qui reçoit des informations d'état fournies par l'appelant et s'exécute de façon asynchrone quand le Task cible se termine et retourne une valeur.

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

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

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

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

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

Paramètres de type

TResult

Type du résultat produit par la continuation.

Paramètres

continuationFunction: Func<Task,Object,TResult>

Fonction à exécuter quand Task 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<TResult>

Nouvelle Task<TResult> de continuation.

Exceptions

ArgumentNullException

L'argument continuationFunction a la valeur null.

Remarques

S’applique à

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

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

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

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

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

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

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

Paramètres de type

TResult

Type du résultat produit par la continuation.

Paramètres

continuationFunction: Func<Task,TResult>

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<TResult>

Nouvelle tâche de continuation.

Exceptions

ObjectDisposedException

Task a été supprimé.

ArgumentNullException

L’argument continuationFunction a la valeur null.

Exemples

L’exemple suivant montre comment utiliser la méthode ContinueWith :

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Imports System.Threading
Imports System.Threading.Tasks

Module ContinuationDemo

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

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


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

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


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

Remarques

S’applique à

Partager via

Task.ContinueWith Méthode

Définition

Surcharges

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

Paramètres

Retours

Exceptions

Remarques

S’applique à

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

Paramètres

Retours

Exceptions

Exemples

Remarques

S’applique à

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

Paramètres

Retours

Exceptions

Remarques

S’applique à

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

Paramètres

Retours

Exceptions

Remarques

S’applique à

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

Paramètres

Retours

Exceptions

Remarques

S’applique à

ContinueWith(Action<Task>)

Paramètres

Retours

Exceptions

Exemples

Remarques

S’applique à

ContinueWith(Action<Task>, TaskContinuationOptions)

Paramètres

Retours

Exceptions

Exemples

Remarques

S’applique à

ContinueWith(Action<Task>, CancellationToken)

Paramètres

Retours

Exceptions

Remarques

S’applique à

ContinueWith(Action<Task,Object>, Object)

Paramètres

Retours

Exceptions

Remarques

S’applique à

ContinueWith(Action<Task>, TaskScheduler)

Paramètres

Retours

Exceptions

Remarques

S’applique à

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

Paramètres de type

Paramètres

Retours

Exceptions

Remarques

S’applique à

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

Paramètres de type

Paramètres

Retours

Exceptions

Remarques