Task.ContinueWith Metodo

Riferimento

Definizione

Spazio dei nomi:: System.Threading.Tasks

Assembly:: System.Threading.Tasks.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Crea una continuazione che viene eseguita in modo asincrono al completamento dell'oggetto Task di destinazione.

Overload

ContinueWith(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una continuazione che riceve informazioni sullo stato fornite dal chiamante e un token di annullamento e che viene eseguita al completamento dell'oggetto Task di destinazione. La continuazione viene eseguita in base a un set di condizioni specificate e usa un'utilità di pianificazione specificata.
ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una continuazione che viene eseguita al completamento dell'attività di destinazione in base all'oggetto TaskContinuationOptions specificato. La continuazione riceve un token di annullamento e usa un'utilità di pianificazione specificata.
ContinueWith(Action<Task,Object>, Object, TaskScheduler)	Crea una continuazione che riceve informazioni sullo stato fornite dal chiamante e viene eseguita in modo asincrono al completamento dell'oggetto Task di destinazione. La continuazione usa un'utilità di pianificazione specificata.
ContinueWith(Action<Task,Object>, Object, TaskContinuationOptions)	Crea una continuazione che riceve informazioni sullo stato fornite dal chiamante e viene eseguita al completamento dell'oggetto Task di destinazione. La continuazione viene eseguita in base a un set di condizioni specificate.
ContinueWith(Action<Task,Object>, Object, CancellationToken)	Crea una continuazione che riceve informazioni sullo stato fornite dal chiamante e un token di annullamento e che viene eseguita in modo asincrono al completamento dell'oggetto Task di destinazione.
ContinueWith(Action<Task>)	Crea una continuazione che viene eseguita in modo asincrono al completamento dell'oggetto Task di destinazione.
ContinueWith(Action<Task>, TaskContinuationOptions)	Crea una continuazione che viene eseguita al completamento dell'attività di destinazione in base all'oggetto TaskContinuationOptions specificato.
ContinueWith(Action<Task>, CancellationToken)	Crea una continuazione che riceve un token di annullamento e viene eseguita in modo asincrono al completamento dell'oggetto Task di destinazione.
ContinueWith(Action<Task,Object>, Object)	Crea una continuazione che riceve informazioni sullo stato fornite dal chiamante e viene eseguita al completamento dell'oggetto Task di destinazione.
ContinueWith(Action<Task>, TaskScheduler)	Crea una continuazione che viene eseguita in modo asincrono al completamento dell'oggetto Task di destinazione. La continuazione usa un'utilità di pianificazione specificata.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskScheduler)	Crea una continuazione che viene eseguita in modo asincrono al completamento dell'oggetto Task di destinazione. La continuazione riceve informazioni sullo stato fornite dal chiamante e usa un'utilità di pianificazione specificata.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una continuazione che viene eseguita in base alle opzioni specificate per la continuazione delle attività al completamento dell'oggetto Task di destinazione, quindi restituisce un valore. La continuazione riceve informazioni sullo stato fornite dal chiamante e un token di annullamento, quindi usa l'utilità di pianificazione specificata.
ContinueWith<TResult>(Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una continuazione che viene eseguita in base alle opzioni di continuazione specificate e restituisce un valore. La continuazione riceve un token di annullamento e usa un'utilità di pianificazione specificata.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken)	Crea una continuazione che viene eseguita in modo asincrono al completamento dell'oggetto Task di destinazione e restituisce un valore. La continuazione riceve informazioni sullo stato fornite dal chiamante e un token di annullamento.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskContinuationOptions)	Crea una continuazione che viene eseguita in base alle opzioni specificate per la continuazione delle attività al completamento dell'oggetto Task di destinazione. La continuazione riceve informazioni sullo stato fornite dal chiamante.
ContinueWith<TResult>(Func<Task,TResult>, TaskContinuationOptions)	Crea una continuazione che viene eseguita in base alle opzioni di continuazione specificate e restituisce un valore.
ContinueWith<TResult>(Func<Task,TResult>, TaskScheduler)	Crea una continuazione che viene eseguita in modo asincrono al completamento dell'oggetto Task di destinazione e restituisce un valore. La continuazione usa un'utilità di pianificazione specificata.
ContinueWith<TResult>(Func<Task,TResult>, CancellationToken)	Crea una continuazione che viene eseguita in modo asincrono al completamento dell'oggetto Task di destinazione e restituisce un valore. La continuazione riceve un token di annullamento.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object)	Crea una continuazione che riceve informazioni sullo stato fornite dal chiamante e viene eseguita in modo asincrono al completamento dell'oggetto Task di destinazione, quindi restituisce un valore.
ContinueWith<TResult>(Func<Task,TResult>)	Crea una continuazione che viene eseguita in modo asincrono al completamento dell'oggetto Task<TResult> di destinazione e restituisce un valore.

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

Origine:: Task.cs

Origine:: Task.cs

Origine:: Task.cs

Crea una continuazione che riceve informazioni sullo stato fornite dal chiamante e un token di annullamento e che viene eseguita al completamento dell'oggetto Task di destinazione. La continuazione viene eseguita in base a un set di condizioni specificate e usa un'utilità di pianificazione specificata.

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

Parametri

continuationAction: Action<Task,Object>

Azione da eseguire al completamento di Task. Durante l'esecuzione, l'attività completata e l'oggetto stato fornito dal chiamante verranno passati come argomenti al delegato.

state: Object

Oggetto che rappresenta i dati che devono essere usati dall'azione di continuazione.

cancellationToken: CancellationToken

Oggetto CancellationToken che verrà assegnato alla nuova attività di continuazione.

continuationOptions: TaskContinuationOptions

Opzioni relative alla pianificazione e al comportamento della continuazione. Ciò comprende criteri, ad esempio OnlyOnCanceled, nonché opzioni di esecuzione, ad esempio ExecuteSynchronously.

scheduler: TaskScheduler

Oggetto TaskScheduler da associare all'attività di continuazione e da usare per l'esecuzione.

Restituisce

Task

Nuovo oggetto Task di continuazione.

Eccezioni

ArgumentNullException

Il valore dell'argomento scheduler è null.

ArgumentOutOfRangeException

L'argomento continuationOptions specifica un valore non valido per TaskContinuationOptions.

ObjectDisposedException

Provider CancellationToken già eliminato.

Commenti

L'oggetto restituito Task non verrà pianificato per l'esecuzione fino al completamento dell'attività corrente. Se i criteri specificati tramite il parametro non vengono soddisfatti, l'attività continuationOptions di continuazione verrà annullata anziché pianificata.

Si applica a

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

Origine:: Task.cs

Origine:: Task.cs

Origine:: Task.cs

Crea una continuazione che viene eseguita al completamento dell'attività di destinazione in base all'oggetto TaskContinuationOptions specificato. La continuazione riceve un token di annullamento e usa un'utilità di pianificazione specificata.

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

Parametri

continuationAction: Action<Task>

Azione da eseguire in base alla condizione specificata in continuationOptions. Durante l'esecuzione, l'attività completata verrà passata come argomento al delegato.

cancellationToken: CancellationToken

Oggetto CancellationToken che verrà assegnato alla nuova attività di continuazione.

continuationOptions: TaskContinuationOptions

Opzioni relative alla pianificazione e al comportamento della continuazione. Ciò comprende criteri, ad esempio OnlyOnCanceled, nonché opzioni di esecuzione, ad esempio ExecuteSynchronously.

scheduler: TaskScheduler

Oggetto TaskScheduler da associare all'attività di continuazione e da usare per l'esecuzione.

Restituisce

Task

Nuovo oggetto Task di continuazione.

Eccezioni

ObjectDisposedException

L'oggetto CancellationTokenSource che ha creato il token è già stato eliminato.

ArgumentNullException

L'argomento continuationAction è Null.

-oppure-

L'argomento scheduler è Null.

ArgumentOutOfRangeException

L'argomento continuationOptions specifica un valore non valido per TaskContinuationOptions.

Esempio

Di seguito è riportato un esempio di uso di ContinueWith per eseguire operazioni in background e nei thread dell'interfaccia utente.

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

Commenti

Si applica a

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

Origine:: Task.cs

Origine:: Task.cs

Origine:: Task.cs

Crea una continuazione che riceve informazioni sullo stato fornite dal chiamante e viene eseguita in modo asincrono al completamento dell'oggetto Task di destinazione. La continuazione usa un'utilità di pianificazione specificata.

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

Parametri

continuationAction: Action<Task,Object>

Azione da eseguire al completamento di Task. Durante l'esecuzione, l'attività completata e l'oggetto stato fornito dal chiamante verranno passati come argomenti al delegato.

state: Object

Oggetto che rappresenta i dati che devono essere usati dall'azione di continuazione.

scheduler: TaskScheduler

Oggetto TaskScheduler da associare all'attività di continuazione e da usare per l'esecuzione.

Restituisce

Task

Nuovo oggetto Task di continuazione.

Eccezioni

ArgumentNullException

Il valore dell'argomento scheduler è null.

Commenti

L'oggetto restituito Task non verrà pianificato per l'esecuzione fino al completamento dell'attività corrente, indipendentemente dal fatto che venga completato a causa del completamento, dell'errore dovuto a un'eccezione non gestita o dell'uscita anticipata a causa dell'annullamento.

Si applica a

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

Origine:: Task.cs

Origine:: Task.cs

Origine:: Task.cs

Crea una continuazione che riceve informazioni sullo stato fornite dal chiamante e viene eseguita al completamento dell'oggetto Task di destinazione. La continuazione viene eseguita in base a un set di condizioni specificate.

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

Parametri

continuationAction: Action<Task,Object>

Azione da eseguire al completamento di Task. Durante l'esecuzione, l'attività completata e l'oggetto stato fornito dal chiamante verranno passati come argomenti al delegato.

state: Object

Oggetto che rappresenta i dati che devono essere usati dall'azione di continuazione.

continuationOptions: TaskContinuationOptions

Opzioni relative alla pianificazione e al comportamento della continuazione. Ciò comprende criteri, ad esempio OnlyOnCanceled, nonché opzioni di esecuzione, ad esempio ExecuteSynchronously.

Restituisce

Task

Nuovo oggetto Task di continuazione.

Eccezioni

ArgumentNullException

Il valore dell'argomento continuationAction è null.

ArgumentOutOfRangeException

L'argomento continuationOptions specifica un valore non valido per TaskContinuationOptions.

Commenti

L'oggetto restituito Task non verrà pianificato per l'esecuzione fino al completamento dell'attività corrente. Se i criteri di continuazione specificati tramite il continuationOptions parametro non vengono soddisfatti, l'attività di continuazione verrà annullata anziché pianificata.

Si applica a

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

Origine:: Task.cs

Origine:: Task.cs

Origine:: Task.cs

Crea una continuazione che riceve informazioni sullo stato fornite dal chiamante e un token di annullamento e che viene eseguita in modo asincrono al completamento dell'oggetto Task di destinazione.

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

Parametri

continuationAction: Action<Task,Object>

Azione da eseguire al completamento di Task. Durante l'esecuzione, l'attività completata e l'oggetto stato fornito dal chiamante verranno passati come argomenti al delegato.

state: Object

Oggetto che rappresenta i dati che devono essere usati dall'azione di continuazione.

cancellationToken: CancellationToken

Oggetto CancellationToken che verrà assegnato alla nuova attività di continuazione.

Restituisce

Task

Nuovo oggetto Task di continuazione.

Eccezioni

ArgumentNullException

Il valore dell'argomento continuationAction è null.

ObjectDisposedException

Provider CancellationToken già eliminato.

Commenti

Si applica a

ContinueWith(Action<Task>)

Origine:: Task.cs

Origine:: Task.cs

Origine:: Task.cs

Crea una continuazione che viene eseguita in modo asincrono al completamento dell'oggetto Task di destinazione.

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

Parametri

continuationAction: Action<Task>

Azione da eseguire al completamento di Task. Durante l'esecuzione, l'attività completata verrà passata come argomento al delegato.

Restituisce

Task

Nuovo oggetto Task di continuazione.

Eccezioni

ArgumentNullException

Il valore dell'argomento continuationAction è null.

Esempio

Nell'esempio seguente viene definita un'attività che popola una matrice con 100 valori di data e ora casuali. Usa il ContinueWith(Action<Task>) metodo per selezionare i valori meno recenti e di data più recenti dopo che la matrice è completamente popolata.

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

Poiché un'applicazione console può terminare prima dell'esecuzione dell'attività di continuazione, viene chiamato il Wait() metodo per assicurarsi che la continuazione termini l'esecuzione prima che l'esempio termini.

Per un esempio aggiuntivo, vedere Concatenamento di attività tramite attività di continuazione.

Commenti

Si applica a

ContinueWith(Action<Task>, TaskContinuationOptions)

Origine:: Task.cs

Origine:: Task.cs

Origine:: Task.cs

Crea una continuazione che viene eseguita al completamento dell'attività di destinazione in base all'oggetto TaskContinuationOptions specificato.

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

Parametri

continuationAction: Action<Task>

Azione da eseguire in base alla condizione specificata in continuationOptions. Durante l'esecuzione, l'attività completata verrà passata come argomento al delegato.

continuationOptions: TaskContinuationOptions

Opzioni relative alla pianificazione e al comportamento della continuazione. Ciò comprende criteri, ad esempio OnlyOnCanceled, nonché opzioni di esecuzione, ad esempio ExecuteSynchronously.

Restituisce

Task

Nuovo oggetto Task di continuazione.

Eccezioni

ArgumentNullException

L'argomento continuationAction è Null.

ArgumentOutOfRangeException

L'argomento continuationOptions specifica un valore non valido per TaskContinuationOptions.

Esempio

Nell'esempio seguente viene illustrato l'uso TaskContinuationOptions di per specificare che un'attività di continuazione deve essere eseguita in modo sincrono al termine dell'attività precedente. Se l'attività specificata è già stata completata al momento ContinueWith della chiamata, la continuazione sincrona verrà eseguita sul thread che chiama 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

Commenti

Si applica a

ContinueWith(Action<Task>, CancellationToken)

Origine:: Task.cs

Origine:: Task.cs

Origine:: Task.cs

Crea una continuazione che riceve un token di annullamento e viene eseguita in modo asincrono al completamento dell'oggetto Task di destinazione.

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

Parametri

continuationAction: Action<Task>

Azione da eseguire al completamento di Task. Durante l'esecuzione, l'attività completata verrà passata come argomento al delegato.

cancellationToken: CancellationToken

Oggetto CancellationToken che verrà assegnato alla nuova attività di continuazione.

Restituisce

Task

Nuovo oggetto Task di continuazione.

Eccezioni

ObjectDisposedException

L'oggetto CancellationTokenSource che ha creato il token è già stato eliminato.

ArgumentNullException

L'argomento continuationAction è Null.

Commenti

Si applica a

ContinueWith(Action<Task,Object>, Object)

Origine:: Task.cs

Origine:: Task.cs

Origine:: Task.cs

Crea una continuazione che riceve informazioni sullo stato fornite dal chiamante e viene eseguita al completamento dell'oggetto Task di destinazione.

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

Parametri

continuationAction: Action<Task,Object>

Azione da eseguire al completamento dell'attività. Durante l'esecuzione, l'attività completata e l'oggetto stato fornito dal chiamante vengono passati come argomenti al delegato.

state: Object

Oggetto che rappresenta i dati che devono essere usati dall'azione di continuazione.

Restituisce

Task

Nuova attività di continuazione.

Eccezioni

ArgumentNullException

Il valore dell'argomento continuationAction è null.

Commenti

L'oggetto restituito Task non verrà pianificato per l'esecuzione fino al completamento dell'attività corrente, se viene completato a causa del completamento corretto, dell'errore a causa di un'eccezione non gestita o dell'uscita anticipata a causa dell'annullamento.

Si applica a

ContinueWith(Action<Task>, TaskScheduler)

Origine:: Task.cs

Origine:: Task.cs

Origine:: Task.cs

Crea una continuazione che viene eseguita in modo asincrono al completamento dell'oggetto Task di destinazione. La continuazione usa un'utilità di pianificazione specificata.

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

Parametri

continuationAction: Action<Task>

Azione da eseguire al completamento di Task. Durante l'esecuzione, l'attività completata verrà passata come argomento al delegato.

scheduler: TaskScheduler

Oggetto TaskScheduler da associare all'attività di continuazione e da usare per l'esecuzione.

Restituisce

Task

Nuovo oggetto Task di continuazione.

Eccezioni

ObjectDisposedException

L'interfaccia Task è stata eliminata.

ArgumentNullException

Il valore dell'argomento continuationAction è null.

-oppure-

L'argomento scheduler è Null.

Commenti

Si applica a

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

Origine:: Task.cs

Origine:: Task.cs

Origine:: Task.cs

Crea una continuazione che viene eseguita in modo asincrono al completamento dell'oggetto Task di destinazione. La continuazione riceve informazioni sullo stato fornite dal chiamante e usa un'utilità di pianificazione specificata.

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)

Parametri di tipo

TResult

Tipo del risultato prodotto dalla continuazione.

Parametri

continuationFunction: Func<Task,Object,TResult>

Funzione da eseguire al completamento di Task. Durante l'esecuzione, l'attività completata e l'oggetto stato fornito dal chiamante verranno passati come argomenti al delegato.

state: Object

Oggetto che rappresenta i dati che devono essere usati dalla funzione di continuazione.

scheduler: TaskScheduler

Oggetto TaskScheduler da associare all'attività di continuazione e da usare per l'esecuzione.

Restituisce

Task<TResult>

Nuovo oggetto Task<TResult> di continuazione.

Eccezioni

ArgumentNullException

Il valore dell'argomento scheduler è null.

Commenti

L'oggetto restituito Task<TResult> non verrà pianificato per l'esecuzione fino al completamento dell'attività corrente, indipendentemente dal fatto che venga completato a causa del completamento, dell'errore dovuto a un'eccezione non gestita o dell'uscita anticipata a causa dell'annullamento.

Si applica a

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

Origine:: Task.cs

Origine:: Task.cs

Origine:: Task.cs

Crea una continuazione che viene eseguita in base alle opzioni specificate per la continuazione delle attività al completamento dell'oggetto Task di destinazione, quindi restituisce un valore. La continuazione riceve informazioni sullo stato fornite dal chiamante e un token di annullamento, quindi usa l'utilità di pianificazione specificata.

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)

Parametri di tipo

TResult

Tipo del risultato prodotto dalla continuazione.

Parametri

continuationFunction: Func<Task,Object,TResult>

Funzione da eseguire al completamento di Task. Durante l'esecuzione, l'attività completata e l'oggetto stato fornito dal chiamante verranno passati come argomenti al delegato.

state: Object

Oggetto che rappresenta i dati che devono essere usati dalla funzione di continuazione.

cancellationToken: CancellationToken

Oggetto CancellationToken che verrà assegnato alla nuova attività di continuazione.

continuationOptions: TaskContinuationOptions

Opzioni relative alla pianificazione e al comportamento della continuazione. Ciò comprende criteri, ad esempio OnlyOnCanceled, nonché opzioni di esecuzione, ad esempio ExecuteSynchronously.

scheduler: TaskScheduler

Oggetto TaskScheduler da associare all'attività di continuazione e da usare per l'esecuzione.

Restituisce

Task<TResult>

Nuovo oggetto Task<TResult> di continuazione.

Eccezioni

ArgumentNullException

Il valore dell'argomento scheduler è null.

ArgumentOutOfRangeException

L'argomento continuationOptions specifica un valore non valido per TaskContinuationOptions.

ObjectDisposedException

Provider CancellationToken già eliminato.

Commenti

L'oggetto restituito Task<TResult> non verrà pianificato per l'esecuzione fino al completamento dell'attività corrente. Se i criteri specificati tramite il continuationOptions parametro non vengono soddisfatti, l'attività di continuazione verrà annullata anziché pianificata.

Si applica a

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

Origine:: Task.cs

Origine:: Task.cs

Origine:: Task.cs

Crea una continuazione che viene eseguita in base alle opzioni di continuazione specificate e restituisce un valore. La continuazione riceve un token di annullamento e usa un'utilità di pianificazione specificata.

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)

Parametri di tipo

TResult

Tipo del risultato prodotto dalla continuazione.

Parametri

continuationFunction: Func<Task,TResult>

Funzione da eseguire in base all'oggetto Specificato continuationOptions. In fase di esecuzione, il delegato verrà passato all'attività completata come argomento.

cancellationToken: CancellationToken

Oggetto CancellationToken che verrà assegnato alla nuova attività di continuazione.

continuationOptions: TaskContinuationOptions

Opzioni relative alla pianificazione e al comportamento della continuazione. Ciò comprende criteri, ad esempio OnlyOnCanceled, nonché opzioni di esecuzione, ad esempio ExecuteSynchronously.

scheduler: TaskScheduler

Oggetto TaskScheduler da associare all'attività di continuazione e da usare per l'esecuzione.

Restituisce

Task<TResult>

Nuovo oggetto Task<TResult> di continuazione.

Eccezioni

ObjectDisposedException

L'interfaccia Task è stata eliminata.

-oppure-

L'oggetto CancellationTokenSource che ha creato il token è già stato eliminato.

ArgumentNullException

L'argomento continuationFunction è Null.

-oppure-

L'argomento scheduler è Null.

ArgumentOutOfRangeException

L'argomento continuationOptions specifica un valore non valido per TaskContinuationOptions.

Esempio

Nell'esempio seguente viene illustrato come utilizzare il metodo ContinueWith con le opzioni di continuazione:

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

Commenti

Si applica a

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

Origine:: Task.cs

Origine:: Task.cs

Origine:: Task.cs

Crea una continuazione che viene eseguita in modo asincrono al completamento dell'oggetto Task di destinazione e restituisce un valore. La continuazione riceve informazioni sullo stato fornite dal chiamante e un token di annullamento.

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)

Parametri di tipo

TResult

Tipo del risultato prodotto dalla continuazione.

Parametri

continuationFunction: Func<Task,Object,TResult>

Funzione da eseguire al completamento di Task. Durante l'esecuzione, l'attività completata e l'oggetto stato fornito dal chiamante verranno passati come argomenti al delegato.

state: Object

Oggetto che rappresenta i dati che devono essere usati dalla funzione di continuazione.

cancellationToken: CancellationToken

Oggetto CancellationToken che verrà assegnato alla nuova attività di continuazione.

Restituisce

Task<TResult>

Nuovo oggetto Task<TResult> di continuazione.

Eccezioni

ArgumentNullException

Il valore dell'argomento continuationFunction è null.

ObjectDisposedException

Provider CancellationToken già eliminato.

Commenti

Si applica a

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

Origine:: Task.cs

Origine:: Task.cs

Origine:: Task.cs

Crea una continuazione che viene eseguita in base alle opzioni specificate per la continuazione delle attività al completamento dell'oggetto Task di destinazione. La continuazione riceve informazioni sullo stato fornite dal chiamante.

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)

Parametri di tipo

TResult

Tipo del risultato prodotto dalla continuazione.

Parametri

continuationFunction: Func<Task,Object,TResult>

Funzione da eseguire al completamento di Task. Durante l'esecuzione, l'attività completata e l'oggetto stato fornito dal chiamante verranno passati come argomenti al delegato.

state: Object

Oggetto che rappresenta i dati che devono essere usati dalla funzione di continuazione.

continuationOptions: TaskContinuationOptions

Opzioni relative alla pianificazione e al comportamento della continuazione. Ciò comprende criteri, ad esempio OnlyOnCanceled, nonché opzioni di esecuzione, ad esempio ExecuteSynchronously.

Restituisce

Task<TResult>

Nuovo oggetto Task<TResult> di continuazione.

Eccezioni

ArgumentNullException

Il valore dell'argomento continuationFunction è null.

ArgumentOutOfRangeException

L'argomento continuationOptions specifica un valore non valido per TaskContinuationOptions.

Commenti

L'oggetto restituito Task<TResult> non verrà pianificato per l'esecuzione fino al completamento dell'attività corrente. Se i criteri di continuazione specificati tramite il continuationOptions parametro non vengono soddisfatti, l'attività di continuazione verrà annullata anziché pianificata.

Si applica a

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

Origine:: Task.cs

Origine:: Task.cs

Origine:: Task.cs

Crea una continuazione che viene eseguita in base alle opzioni di continuazione specificate e restituisce un valore.

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)

Parametri di tipo

TResult

Tipo del risultato prodotto dalla continuazione.

Parametri

continuationFunction: Func<Task,TResult>

Funzione da eseguire in base alla condizione specificata in continuationOptions. Durante l'esecuzione, l'attività completata verrà passata come argomento al delegato.

continuationOptions: TaskContinuationOptions

Opzioni relative alla pianificazione e al comportamento della continuazione. Ciò comprende criteri, ad esempio OnlyOnCanceled, nonché opzioni di esecuzione, ad esempio ExecuteSynchronously.

Restituisce

Task<TResult>

Nuovo oggetto Task<TResult> di continuazione.

Eccezioni

ObjectDisposedException

L'interfaccia Task è stata eliminata.

ArgumentNullException

L'argomento continuationFunction è Null.

ArgumentOutOfRangeException

L'argomento continuationOptions specifica un valore non valido per TaskContinuationOptions.

Commenti

Si applica a

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

Origine:: Task.cs

Origine:: Task.cs

Origine:: Task.cs

Crea una continuazione che viene eseguita in modo asincrono al completamento dell'oggetto Task di destinazione e restituisce un valore. La continuazione usa un'utilità di pianificazione specificata.

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)

Parametri di tipo

TResult

Tipo del risultato prodotto dalla continuazione.

Parametri

continuationFunction: Func<Task,TResult>

Funzione da eseguire al completamento di Task. Durante l'esecuzione, l'attività completata verrà passata come argomento al delegato.

scheduler: TaskScheduler

Oggetto TaskScheduler da associare all'attività di continuazione e da usare per l'esecuzione.

Restituisce

Task<TResult>

Nuovo oggetto Task<TResult> di continuazione.

Eccezioni

ObjectDisposedException

L'interfaccia Task è stata eliminata.

ArgumentNullException

L'argomento continuationFunction è Null.

-oppure-

L'argomento scheduler è Null.

Commenti

Si applica a

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

Origine:: Task.cs

Origine:: Task.cs

Origine:: Task.cs

Crea una continuazione che viene eseguita in modo asincrono al completamento dell'oggetto Task di destinazione e restituisce un valore. La continuazione riceve un token di annullamento.

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)

Parametri di tipo

TResult

Tipo del risultato prodotto dalla continuazione.

Parametri

continuationFunction: Func<Task,TResult>

Funzione da eseguire al completamento di Task. Durante l'esecuzione, l'attività completata verrà passata come argomento al delegato.

cancellationToken: CancellationToken

Oggetto CancellationToken che verrà assegnato alla nuova attività di continuazione.

Restituisce

Task<TResult>

Nuovo oggetto Task<TResult> di continuazione.

Eccezioni

ObjectDisposedException

L'interfaccia Task è stata eliminata.

-oppure-

L'oggetto CancellationTokenSource che ha creato il token è già stato eliminato.

ArgumentNullException

L'argomento continuationFunction è Null.

Commenti

Si applica a

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

Origine:: Task.cs

Origine:: Task.cs

Origine:: Task.cs

Crea una continuazione che riceve informazioni sullo stato fornite dal chiamante e viene eseguita in modo asincrono al completamento dell'oggetto Task di destinazione, quindi restituisce un valore.

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)

Parametri di tipo

TResult

Tipo del risultato prodotto dalla continuazione.

Parametri

continuationFunction: Func<Task,Object,TResult>

Funzione da eseguire al completamento di Task. Durante l'esecuzione, l'attività completata e l'oggetto stato fornito dal chiamante verranno passati come argomenti al delegato.

state: Object

Oggetto che rappresenta i dati che devono essere usati dalla funzione di continuazione.

Restituisce

Task<TResult>

Nuovo oggetto Task<TResult> di continuazione.

Eccezioni

ArgumentNullException

Il valore dell'argomento continuationFunction è null.

Commenti

Si applica a

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

Origine:: Task.cs

Origine:: Task.cs

Origine:: Task.cs

Crea una continuazione che viene eseguita in modo asincrono al completamento dell'oggetto Task<TResult> di destinazione e restituisce un valore.

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)

Parametri di tipo

TResult

Tipo del risultato prodotto dalla continuazione.

Parametri

continuationFunction: Func<Task,TResult>

Funzione da eseguire al completamento di Task<TResult>. Durante l'esecuzione, l'attività completata verrà passata come argomento al delegato.

Restituisce

Task<TResult>

Nuova attività di continuazione.

Eccezioni

ObjectDisposedException

L'interfaccia Task è stata eliminata.

ArgumentNullException

L'argomento continuationFunction è Null.

Esempio

Nell'esempio seguente viene illustrato come utilizzare il metodo 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

Commenti

Si applica a

Condividi tramite

Task.ContinueWith Metodo

Definizione

Overload

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

Parametri

Restituisce

Eccezioni

Commenti

Si applica a

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

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Si applica a

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

Parametri

Restituisce

Eccezioni

Commenti

Si applica a

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

Parametri

Restituisce

Eccezioni

Commenti

Si applica a

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

Parametri

Restituisce

Eccezioni

Commenti

Si applica a

ContinueWith(Action<Task>)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Si applica a

ContinueWith(Action<Task>, TaskContinuationOptions)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Si applica a

ContinueWith(Action<Task>, CancellationToken)

Parametri

Restituisce

Eccezioni

Commenti

Si applica a

ContinueWith(Action<Task,Object>, Object)

Parametri

Restituisce

Eccezioni

Commenti

Si applica a

ContinueWith(Action<Task>, TaskScheduler)

Parametri

Restituisce

Eccezioni

Commenti

Si applica a

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

Parametri di tipo

Parametri

Restituisce

Eccezioni

Commenti

Si applica a

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

Parametri di tipo

Parametri

Restituisce

Eccezioni

Commenti