Task<TResult>.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 un'attività di continuazione che viene eseguita in seguito al completamento di un'altra attività.

Overload

ContinueWith(Action<Task<TResult>,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una continuazione che viene eseguita al completamento dell'oggetto Task<TResult> di destinazione.
ContinueWith(Action<Task<TResult>,Object>, Object, TaskScheduler)	Crea una continuazione che viene eseguita al completamento dell'oggetto Task<TResult> di destinazione.
ContinueWith(Action<Task<TResult>,Object>, Object, TaskContinuationOptions)	Crea una continuazione che viene eseguita al completamento dell'oggetto Task<TResult> di destinazione.
ContinueWith(Action<Task<TResult>,Object>, Object, CancellationToken)	Crea una continuazione che viene eseguita al completamento dell'oggetto Task<TResult> di destinazione.
ContinueWith(Action<Task<TResult>>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una continuazione che viene eseguita in base alla condizione specificata in `continuationOptions`.
ContinueWith(Action<Task<TResult>>, TaskContinuationOptions)	Crea una continuazione che viene eseguita in base alla condizione specificata in `continuationOptions`.
ContinueWith(Action<Task<TResult>>, CancellationToken)	Crea una continuazione annullabile che viene eseguita in modo asincrono al completamento dell'oggetto Task<TResult> di destinazione.
ContinueWith(Action<Task<TResult>,Object>, Object)	Crea una continuazione che riceve informazioni sullo stato e viene eseguita al completamento dell'oggetto Task<TResult> di destinazione.
ContinueWith(Action<Task<TResult>>)	Crea una continuazione che viene eseguita in modo asincrono al completamento dell'attività di destinazione.
ContinueWith(Action<Task<TResult>>, TaskScheduler)	Crea una continuazione che viene eseguita in modo asincrono al completamento dell'oggetto Task<TResult> di destinazione.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una continuazione che viene eseguita al completamento dell'oggetto Task<TResult> di destinazione.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una continuazione che viene eseguita in base alla condizione specificata in `continuationOptions`.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, TaskScheduler)	Crea una continuazione che viene eseguita al completamento dell'oggetto Task<TResult> di destinazione.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, CancellationToken)	Crea una continuazione che viene eseguita al completamento dell'oggetto Task<TResult> di destinazione.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, TaskContinuationOptions)	Crea una continuazione che viene eseguita al completamento dell'oggetto Task<TResult> di destinazione.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, TaskContinuationOptions)	Crea una continuazione che viene eseguita in base alla condizione specificata in `continuationOptions`.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, CancellationToken)	Crea una continuazione che viene eseguita in modo asincrono al completamento dell'oggetto Task<TResult> di destinazione.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object)	Crea una continuazione che viene eseguita al completamento dell'oggetto Task<TResult> di destinazione.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>)	Crea una continuazione che viene eseguita in modo asincrono al completamento dell'oggetto Task<TResult> di destinazione.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, TaskScheduler)	Crea una continuazione che viene eseguita in modo asincrono al completamento dell'oggetto Task<TResult> di destinazione.

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

Origine:: Future.cs

Origine:: Future.cs

Origine:: Future.cs

Crea una continuazione che viene eseguita al completamento dell'oggetto Task<TResult> di destinazione.

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

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

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

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

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

Parametri

continuationAction: Action<Task<TResult>,Object>

Azione da eseguire al completamento di Task<TResult>. 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 continuationOptions parametro non vengono soddisfatti, l'attività di continuazione verrà annullata anziché pianificata.

Vedi anche

Concatenamento di attività tramite attività di continuazione

Si applica a

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

Origine:: Future.cs

Origine:: Future.cs

Origine:: Future.cs

Crea una continuazione che viene eseguita al completamento dell'oggetto Task<TResult> di destinazione.

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

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

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

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

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

Parametri

continuationAction: Action<Task<TResult>,Object>

Azione da eseguire al completamento di Task<TResult>. 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.

Vedi anche

Concatenamento di attività tramite attività di continuazione

Si applica a

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

Origine:: Future.cs

Origine:: Future.cs

Origine:: Future.cs

Crea una continuazione che viene eseguita al completamento dell'oggetto Task<TResult> di destinazione.

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

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

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

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

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

Parametri

continuationAction: Action<Task<TResult>,Object>

Azione da eseguire al completamento di Task<TResult>. 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.

Vedi anche

Concatenamento di attività tramite attività di continuazione

Si applica a

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

Origine:: Future.cs

Origine:: Future.cs

Origine:: Future.cs

Crea una continuazione che viene eseguita al completamento dell'oggetto Task<TResult> di destinazione.

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

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

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

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

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

Parametri

continuationAction: Action<Task<TResult>,Object>

Azione da eseguire al completamento di Task<TResult>. 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

Vedi anche

Concatenamento di attività tramite attività di continuazione

Si applica a

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

Origine:: Future.cs

Origine:: Future.cs

Origine:: Future.cs

Crea una continuazione che viene eseguita in base alla condizione specificata in continuationOptions.

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

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

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

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

Parametri

continuationAction: Action<Task<TResult>>

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'interfaccia Task<TResult> è stata eliminata.

-oppure-

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

ArgumentNullException

Il valore dell'argomento continuationAction è null.

-oppure-

Il valore dell'argomento scheduler è 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 specificati tramite il parametro non vengono soddisfatti, l'attività continuationOptions di continuazione verrà annullata anziché pianificata. Per altre informazioni, vedere Concatenamento di attività tramite attività di continuazione.

Vedi anche

Si applica a

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

Origine:: Future.cs

Origine:: Future.cs

Origine:: Future.cs

Crea una continuazione che viene eseguita in base alla condizione specificata in continuationOptions.

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

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

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

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

Parametri

continuationAction: Action<Task<TResult>>

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

ObjectDisposedException

L'interfaccia Task<TResult> è stata eliminata.

ArgumentNullException

Il valore dell'argomento continuationAction è null.

ArgumentOutOfRangeException

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

Commenti

Per altre informazioni, vedere Concatenamento di attività tramite attività di continuazione.

Vedi anche

Si applica a

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

Origine:: Future.cs

Origine:: Future.cs

Origine:: Future.cs

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

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

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

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

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

Parametri

continuationAction: Action<Task<TResult>>

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

cancellationToken: CancellationToken

Token di annullamento che viene passato alla nuova attività di continuazione.

Restituisce

Task

Nuova attività di continuazione.

Eccezioni

ObjectDisposedException

L'interfaccia Task<TResult> è stata eliminata.

-oppure-

L'oggetto CancellationTokenSource che ha creato cancellationToken è stato eliminato.

ArgumentNullException

Il valore dell'argomento continuationAction è null.

Esempio

Nell'esempio seguente viene creata un'attività precedente che usa il Sieve di Eratosthenes per calcolare i numeri primi tra 1 e un valore immesso dall'utente. Una matrice viene usata per contenere informazioni sui numeri primi. L'indice della matrice rappresenta il numero e il valore dell'elemento indica se il numero è composito (il relativo valore è ) o prime (il relativo valore è truefalse). Questa attività viene quindi passata a un'attività di continuazione, responsabile dell'estrazione dei numeri primi dalla matrice integer e della visualizzazione.

Un token di annullamento viene passato sia al precedente che all'attività di continuazione. Un System.Timers.Timer oggetto viene usato per definire un valore di timeout di 100 millisecondi. Se l'evento viene generato, viene chiamato il metodo e il CancellationTokenSource.Cancel token di annullamento viene usato per richiedere l'annullamento delle attività.

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

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

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

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

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

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

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

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

Module Example
   Dim ts As CancellationTokenSource

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

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

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

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

In genere, specificando un valore di circa 100.000, l'intervallo di timeout scade e l'evento Timer.Elapsed verrà generato e la richiesta di annullamento da impostare.

Commenti

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

Vedi anche

Si applica a

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

Origine:: Future.cs

Origine:: Future.cs

Origine:: Future.cs

Crea una continuazione che riceve informazioni sullo stato e viene eseguita al completamento dell'oggetto Task<TResult> di destinazione.

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

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

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

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

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

Parametri

continuationAction: Action<Task<TResult>,Object>

Azione da eseguire al completamento di Task<TResult>. Quando viene eseguito, il delegato viene passato all'attività completata e all'oggetto stato fornito dal chiamante come argomenti.

state: Object

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

Restituisce

Task

Nuovo oggetto Task di continuazione.

Eccezioni

ArgumentNullException

Il valore dell'argomento continuationAction è null.

Esempio

Nell'esempio seguente viene creata un'attività passata un intero compreso tra 2 e 20 e restituisce una matrice contenente i primi dieci esponenti (da n 1 a n¹⁰) di tale numero. Un'attività di continuazione è quindi responsabile della visualizzazione degli esponenti. Viene passato sia il precedente che il numero originale i cui esponenti generano l'antecedente.

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

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

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

Imports System.Threading
Imports System.Threading.Tasks

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

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

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

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

Commenti

Vedi anche

Concatenamento di attività tramite attività di continuazione

Si applica a

ContinueWith(Action<Task<TResult>>)

Origine:: Future.cs

Origine:: Future.cs

Origine:: Future.cs

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

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

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

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

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

Parametri

continuationAction: Action<Task<TResult>>

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

Restituisce

Task

Nuova attività di continuazione.

Eccezioni

ObjectDisposedException

L'interfaccia Task<TResult> è stata eliminata.

ArgumentNullException

Il valore dell'argomento continuationAction è null.

Esempio

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

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

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

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

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

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

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

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

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

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

Commenti

Vedi anche

Si applica a

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

Origine:: Future.cs

Origine:: Future.cs

Origine:: Future.cs

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

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

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

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

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

Parametri

continuationAction: Action<Task<TResult>>

Azione da eseguire al completamento di Task<TResult>. 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<TResult> è stata eliminata.

ArgumentNullException

Il valore dell'argomento continuationAction è null.

-oppure-

Il valore dell'argomento scheduler è null.

Commenti

Vedi anche

Si applica a

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

Origine:: Future.cs

Origine:: Future.cs

Origine:: Future.cs

Crea una continuazione che viene eseguita al completamento dell'oggetto Task<TResult> di destinazione.

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

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

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

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

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

Parametri di tipo

TNewResult

Tipo del risultato prodotto dalla continuazione.

Parametri

continuationFunction: Func<Task<TResult>,Object,TNewResult>

Funzione da eseguire al completamento di Task<TResult>. 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à.

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

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

Il restituito Task<TResult> non verrà pianificato per l'esecuzione fino al completamento dell'attività corrente, se viene completato a causa dell'esecuzione del completamento, dell'errore dovuto a un'eccezione non gestita o all'uscita anticipata a causa dell'annullamento.

Se continuationFunctioneseguito, deve restituire un Task<TResult>oggetto . Lo stato di completamento dell'attività verrà trasferito all'attività restituita dalla Task<TResult>.ContinueWith chiamata.

Vedi anche

Concatenamento di attività tramite attività di continuazione

Si applica a

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

Origine:: Future.cs

Origine:: Future.cs

Origine:: Future.cs

Crea una continuazione che viene eseguita in base alla condizione specificata in continuationOptions.

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

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

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

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

Parametri di tipo

TNewResult

Tipo del risultato prodotto dalla continuazione.

Parametri

continuationFunction: Func<Task<TResult>,TNewResult>

Funzione da eseguire in base alla condizione specificata in continuationOptions.

Quando tale funzione viene eseguita, questa attività completata verrà passata come argomento al delegato.

cancellationToken: CancellationToken

Oggetto CancellationToken che verrà assegnato alla nuova attività.

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

Nuovo oggetto Task<TResult> di continuazione.

Eccezioni

ObjectDisposedException

L'interfaccia Task<TResult> è stata eliminata.

-oppure-

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

ArgumentNullException

Il valore dell'argomento continuationFunction è null.

-oppure-

Il valore dell'argomento scheduler è 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, 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.

L'oggetto continuationFunction, quando eseguito, deve restituire un oggetto Task<TResult>.

Vedi anche

Si applica a

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

Origine:: Future.cs

Origine:: Future.cs

Origine:: Future.cs

Crea una continuazione che viene eseguita al completamento dell'oggetto Task<TResult> di destinazione.

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

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

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

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

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

Parametri di tipo

TNewResult

Tipo del risultato prodotto dalla continuazione.

Parametri

continuationFunction: Func<Task<TResult>,Object,TNewResult>

Funzione da eseguire al completamento di Task<TResult>. 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<TNewResult>

Nuovo oggetto Task<TResult> di continuazione.

Eccezioni

ArgumentNullException

Il valore dell'argomento scheduler è null.

Commenti

Vedi anche

Concatenamento di attività tramite attività di continuazione

Si applica a

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

Origine:: Future.cs

Origine:: Future.cs

Origine:: Future.cs

Crea una continuazione che viene eseguita al completamento dell'oggetto Task<TResult> di destinazione.

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

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

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

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

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

Parametri di tipo

TNewResult

Tipo del risultato prodotto dalla continuazione.

Parametri

continuationFunction: Func<Task<TResult>,Object,TNewResult>

Funzione da eseguire al completamento di Task<TResult>. 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à.

Restituisce

Task<TNewResult>

Nuovo oggetto Task<TResult> di continuazione.

Eccezioni

ArgumentNullException

Il valore dell'argomento continuationFunction è null.

ObjectDisposedException

Provider CancellationToken già eliminato.

Commenti

Vedi anche

Concatenamento di attività tramite attività di continuazione

Si applica a

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

Origine:: Future.cs

Origine:: Future.cs

Origine:: Future.cs

Crea una continuazione che viene eseguita al completamento dell'oggetto Task<TResult> di destinazione.

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

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

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

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

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

Parametri di tipo

TNewResult

Tipo del risultato prodotto dalla continuazione.

Parametri

continuationFunction: Func<Task<TResult>,Object,TNewResult>

Funzione da eseguire al completamento di Task<TResult>. 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<TNewResult>

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 continuationFunction, quando eseguito, deve restituire un oggetto Task<TResult>. Lo stato di completamento dell'attività verrà trasferito all'attività restituita dalla chiamata ContinueWith.

Vedi anche

Concatenamento di attività tramite attività di continuazione

Si applica a

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

Origine:: Future.cs

Origine:: Future.cs

Origine:: Future.cs

Crea una continuazione che viene eseguita in base alla condizione specificata in continuationOptions.

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

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

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

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

Parametri di tipo

TNewResult

Tipo del risultato prodotto dalla continuazione.

Parametri

continuationFunction: Func<Task<TResult>,TNewResult>

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

Nuovo oggetto Task<TResult> di continuazione.

Eccezioni

ObjectDisposedException

L'interfaccia Task<TResult> è stata eliminata.

ArgumentNullException

Il valore dell'argomento continuationFunction è null.

ArgumentOutOfRangeException

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

Commenti

L'oggetto continuationFunction, quando eseguito, deve restituire un oggetto Task<TResult>.

Vedi anche

Si applica a

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

Origine:: Future.cs

Origine:: Future.cs

Origine:: Future.cs

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

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

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

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

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

Parametri di tipo

TNewResult

Tipo del risultato prodotto dalla continuazione.

Parametri

continuationFunction: Func<Task<TResult>,TNewResult>

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

cancellationToken: CancellationToken

Oggetto CancellationToken che verrà assegnato alla nuova attività.

Restituisce

Task<TNewResult>

Nuovo oggetto Task<TResult> di continuazione.

Eccezioni

ObjectDisposedException

L'interfaccia Task<TResult> è stata eliminata.

-oppure-

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

ArgumentNullException

Il valore dell'argomento continuationFunction è null.

Commenti

Vedi anche

Si applica a

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

Origine:: Future.cs

Origine:: Future.cs

Origine:: Future.cs

Crea una continuazione che viene eseguita al completamento dell'oggetto Task<TResult> di destinazione.

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

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

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

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

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

Parametri di tipo

TNewResult

Tipo del risultato prodotto dalla continuazione.

Parametri

continuationFunction: Func<Task<TResult>,Object,TNewResult>

Funzione da eseguire al completamento di Task<TResult>. 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<TNewResult>

Nuovo oggetto Task<TResult> di continuazione.

Eccezioni

ArgumentNullException

Il valore dell'argomento continuationFunction è null.

Esempio

Nell'esempio seguente viene creata una catena di attività di continuazione. Ogni attività fornisce l'ora corrente, un DateTime oggetto , per l'argomento stato del ContinueWith(Action<Task,Object>, Object) metodo . Ogni DateTime valore rappresenta l'ora in cui viene creata l'attività continua. Ogni attività produce come risultato un secondo DateTime valore che rappresenta l'ora in cui l'attività termina. Al termine di tutte le attività, nell'esempio viene visualizzata la data e l'ora in cui ogni attività di continuazione viene avviata e completata.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Commenti

Vedi anche

Concatenamento di attività tramite attività di continuazione

Si applica a

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

Origine:: Future.cs

Origine:: Future.cs

Origine:: Future.cs

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

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

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

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

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

Parametri di tipo

TNewResult

Tipo del risultato prodotto dalla continuazione.

Parametri

continuationFunction: Func<Task<TResult>,TNewResult>

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

Restituisce

Task<TNewResult>

Nuovo oggetto Task<TResult> di continuazione.

Eccezioni

ObjectDisposedException

L'interfaccia Task<TResult> è stata eliminata.

ArgumentNullException

Il valore dell'argomento continuationFunction è null.

Commenti

Vedi anche

Si applica a

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

Origine:: Future.cs

Origine:: Future.cs

Origine:: Future.cs

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

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

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

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

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

Parametri di tipo

TNewResult

Tipo del risultato prodotto dalla continuazione.

Parametri

continuationFunction: Func<Task<TResult>,TNewResult>

Funzione da eseguire al completamento di Task<TResult>. 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<TNewResult>

Nuovo oggetto Task<TResult> di continuazione.

Eccezioni

ObjectDisposedException

L'interfaccia Task<TResult> è stata eliminata.

ArgumentNullException

Il valore dell'argomento continuationFunction è null.

-oppure-

Il valore dell'argomento scheduler è null.

Commenti

Vedi anche

Si applica a

Condividi tramite

Task<TResult>.ContinueWith Metodo

Definizione

Overload

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

Parametri

Restituisce

Eccezioni

Commenti

Vedi anche

Si applica a

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

Parametri

Restituisce

Eccezioni

Commenti

Vedi anche

Si applica a

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

Parametri

Restituisce

Eccezioni

Commenti

Vedi anche

Si applica a

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

Parametri

Restituisce

Eccezioni

Commenti

Vedi anche

Si applica a

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

Parametri

Restituisce

Eccezioni

Commenti

Vedi anche

Si applica a

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

Parametri

Restituisce

Eccezioni

Commenti

Vedi anche

Si applica a

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

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Vedi anche

Si applica a

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

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Vedi anche

Si applica a

ContinueWith(Action<Task<TResult>>)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Vedi anche

Si applica a

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

Parametri

Restituisce

Eccezioni

Commenti

Vedi anche

Si applica a

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

Parametri di tipo

Parametri