Task<TResult>.ContinueWith Metoda

Reference

Definice

Obor názvů:: System.Threading.Tasks

Sestavení:: System.Threading.Tasks.dll

Sestavení:: System.Runtime.dll

Sestavení:: mscorlib.dll

Sestavení:: netstandard.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Vytvoří úlohu pokračování, která se spustí po dokončení jiné úlohy.

Přetížení

ContinueWith(Action<Task<TResult>,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Vytvoří pokračování, které se spustí po dokončení cíle Task<TResult> .
ContinueWith(Action<Task<TResult>,Object>, Object, TaskScheduler)	Vytvoří pokračování, které se spustí po dokončení cíle Task<TResult> .
ContinueWith(Action<Task<TResult>,Object>, Object, TaskContinuationOptions)	Vytvoří pokračování, které se spustí po dokončení cíle Task<TResult> .
ContinueWith(Action<Task<TResult>,Object>, Object, CancellationToken)	Vytvoří pokračování, které se spustí po dokončení cíle Task<TResult> .
ContinueWith(Action<Task<TResult>>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Vytvoří pokračování, které se spustí podle podmínky zadané v `continuationOptions`.
ContinueWith(Action<Task<TResult>>, TaskContinuationOptions)	Vytvoří pokračování, které se spustí podle podmínky zadané v `continuationOptions`.
ContinueWith(Action<Task<TResult>>, CancellationToken)	Vytvoří zrušitelné pokračování, které se spustí asynchronně po dokončení cíle Task<TResult> .
ContinueWith(Action<Task<TResult>,Object>, Object)	Vytvoří pokračování, které se předají informace o stavu a které se spustí po dokončení cíle Task<TResult> .
ContinueWith(Action<Task<TResult>>)	Vytvoří pokračování, které se spustí asynchronně po dokončení cílové úlohy.
ContinueWith(Action<Task<TResult>>, TaskScheduler)	Vytvoří pokračování, které se spustí asynchronně po dokončení cíle Task<TResult> .
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Vytvoří pokračování, které se spustí po dokončení cíle Task<TResult> .
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Vytvoří pokračování, které se spustí podle podmínky zadané v `continuationOptions`.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, TaskScheduler)	Vytvoří pokračování, které se spustí po dokončení cíle Task<TResult> .
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, CancellationToken)	Vytvoří pokračování, které se spustí po dokončení cíle Task<TResult> .
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, TaskContinuationOptions)	Vytvoří pokračování, které se spustí po dokončení cíle Task<TResult> .
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, TaskContinuationOptions)	Vytvoří pokračování, které se spustí podle podmínky zadané v `continuationOptions`.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, CancellationToken)	Vytvoří pokračování, které se spustí asynchronně po dokončení cíle Task<TResult> .
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object)	Vytvoří pokračování, které se spustí po dokončení cíle Task<TResult> .
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>)	Vytvoří pokračování, které se spustí asynchronně po dokončení cíle Task<TResult> .
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, TaskScheduler)	Vytvoří pokračování, které se spustí asynchronně po dokončení cíle Task<TResult> .

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

Zdroj:: Future.cs

Zdroj:: Future.cs

Zdroj:: Future.cs

Vytvoří pokračování, které se spustí po dokončení cíle Task<TResult> .

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

Parametry

continuationAction: Action<Task<TResult>,Object>

Akce, která se spustí po Task<TResult> dokončení. Při spuštění se delegát předá dokončené úloze a volajícímu objektu stavu jako argumenty.

state: Object

Objekt představující data, která mají být použita akcí pokračování.

cancellationToken: CancellationToken

Hodnota CancellationToken , která bude přiřazena k novému úkolu pokračování.

continuationOptions: TaskContinuationOptions

Možnosti, kdy je pokračování naplánované a jak se chová. To zahrnuje kritéria, jako OnlyOnCanceledje , a také možnosti spuštění, jako ExecuteSynchronouslyje .

scheduler: TaskScheduler

Chcete-li TaskScheduler přidružit úlohu pokračování a použít k jeho provedení.

Návraty

Task

Nové pokračování Task.

Výjimky

ArgumentNullException

Argument scheduler je null.

ArgumentOutOfRangeException

Argument continuationOptions určuje neplatnou hodnotu pro TaskContinuationOptions.

ObjectDisposedException

Poskytnutý soubor CancellationToken již byl odstraněn.

Poznámky

Task Vrácená úloha nebude naplánována k provedení, dokud se nedokončí aktuální úloha. Pokud nebudou splněna kritéria zadaná prostřednictvím parametru continuationOptions , bude úloha pokračování zrušena, místo aby byla naplánována.

Viz také

Řetězení úloh pomocí úloh pokračování

Platí pro

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

Zdroj:: Future.cs

Zdroj:: Future.cs

Zdroj:: Future.cs

Vytvoří pokračování, které se spustí po dokončení cíle Task<TResult> .

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

Parametry

continuationAction: Action<Task<TResult>,Object>

Akce, která se spustí po Task<TResult> dokončení. Při spuštění se delegát předá dokončené úloze a volajícímu objektu stavu jako argumenty.

state: Object

Objekt představující data, která mají být použita akcí pokračování.

scheduler: TaskScheduler

Chcete-li TaskScheduler přidružit úlohu pokračování a použít k jeho provedení.

Návraty

Task

Nové pokračování Task.

Výjimky

ArgumentNullException

Argument scheduler je null.

Poznámky

Vrácené Task úlohy nebudou naplánovány spuštění, dokud se nedokončí aktuální úloha, ať už se dokončí z důvodu úspěšného spuštění do dokončení, selhání kvůli neošetřené výjimce nebo předčasné ukončení z důvodu zrušení.

Viz také

Řetězení úloh pomocí úloh pokračování

Platí pro

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

Zdroj:: Future.cs

Zdroj:: Future.cs

Zdroj:: Future.cs

Vytvoří pokračování, které se spustí po dokončení cíle Task<TResult> .

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

Parametry

continuationAction: Action<Task<TResult>,Object>

Akce, která se spustí po Task<TResult> dokončení. Při spuštění se delegát předá dokončené úloze a volajícímu objektu stavu jako argumenty.

state: Object

Objekt představující data, která mají být použita akcí pokračování.

continuationOptions: TaskContinuationOptions

Možnosti, kdy je pokračování naplánované a jak se chová. To zahrnuje kritéria, jako OnlyOnCanceledje , a také možnosti spuštění, jako ExecuteSynchronouslyje .

Návraty

Task

Nové pokračování Task.

Výjimky

ArgumentNullException

Argument continuationAction je null.

ArgumentOutOfRangeException

Argument continuationOptions určuje neplatnou hodnotu pro TaskContinuationOptions.

Poznámky

Task Vrácená úloha nebude naplánována k provedení, dokud se nedokončí aktuální úloha. Pokud nebudou splněna kritéria pro pokračování zadaná prostřednictvím parametru continuationOptions , úloha pokračování se zruší místo naplánování.

Viz také

Řetězení úloh pomocí úloh pokračování

Platí pro

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

Zdroj:: Future.cs

Zdroj:: Future.cs

Zdroj:: Future.cs

Vytvoří pokračování, které se spustí po dokončení cíle Task<TResult> .

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

Parametry

continuationAction: Action<Task<TResult>,Object>

Akce, která se spustí po Task<TResult> dokončení. Při spuštění se delegát předá dokončené úloze a volajícímu objektu stavu jako argumenty.

state: Object

Objekt představující data, která mají být použita akcí pokračování.

cancellationToken: CancellationToken

Hodnota CancellationToken , která bude přiřazena k novému úkolu pokračování.

Návraty

Task

Nové pokračování Task.

Výjimky

ArgumentNullException

Argument continuationAction je null.

ObjectDisposedException

Poskytnutý soubor CancellationToken již byl odstraněn.

Poznámky

Viz také

Řetězení úloh pomocí úloh pokračování

Platí pro

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

Zdroj:: Future.cs

Zdroj:: Future.cs

Zdroj:: Future.cs

Vytvoří pokračování, které se spustí v souladu s podmínkou zadanou v 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

Parametry

continuationAction: Action<Task<TResult>>

Akce, která se má spustit podle podmínky zadané v continuationOptions. Při spuštění se delegát předá dokončený úkol jako argument.

cancellationToken: CancellationToken

Hodnota CancellationToken , která bude přiřazena k novému úkolu pokračování.

continuationOptions: TaskContinuationOptions

Možnosti, kdy je pokračování naplánované a jak se chová. To zahrnuje kritéria, jako OnlyOnCanceledje , a také možnosti spuštění, jako ExecuteSynchronouslyje .

scheduler: TaskScheduler

Objekt TaskScheduler , který se má přidružit k úloze pokračování a použít k jeho provedení.

Návraty

Task

Nové pokračování Task.

Výjimky

ObjectDisposedException

Byla Task<TResult> zlikvidována.

-nebo-

cancellationToken Vytvořený objekt CancellationTokenSource již byl odstraněn.

ArgumentNullException

Argument continuationAction je null.

-nebo-

Argument scheduler je null.

ArgumentOutOfRangeException

Argument continuationOptions určuje neplatnou hodnotu pro TaskContinuationOptions.

Poznámky

Vrácené Task úlohy nebudou naplánovány k provedení, dokud se nedokončil aktuální úkol. Pokud kritéria zadaná prostřednictvím parametru continuationOptions nejsou splněna, bude úloha pokračování zrušena místo naplánovaného. Další informace najdete v tématu Zřetězování úloh pomocí úloh pokračování.

Viz také

Platí pro

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

Zdroj:: Future.cs

Zdroj:: Future.cs

Zdroj:: Future.cs

Vytvoří pokračování, které se spustí v souladu s podmínkou zadanou v 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

Parametry

continuationAction: Action<Task<TResult>>

Akce do v souladu s podmínkou zadanou v continuationOptions. Po spuštění se delegát předá dokončený úkol jako argument.

continuationOptions: TaskContinuationOptions

Možnosti, kdy je pokračování naplánované a jak se chová. To zahrnuje kritéria, jako OnlyOnCanceledje , a také možnosti spuštění, jako ExecuteSynchronouslyje .

Návraty

Task

Nové pokračování Task.

Výjimky

ObjectDisposedException

Byla Task<TResult> odstraněna.

ArgumentNullException

Argument continuationAction je null.

ArgumentOutOfRangeException

Argument continuationOptions určuje neplatnou hodnotu pro TaskContinuationOptions.

Poznámky

Vrácené Task úlohy nebudou naplánovány k provedení, dokud se nedokončil aktuální úkol. Pokud nejsou splněna kritéria pro pokračování zadaná prostřednictvím parametru continuationOptions , bude úloha pokračování zrušena místo naplánovaného.

Další informace najdete v tématu Zřetězování úloh pomocí úloh pokračování.

Viz také

Platí pro

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

Zdroj:: Future.cs

Zdroj:: Future.cs

Zdroj:: Future.cs

Vytvoří zrušitelné pokračování, které se spustí asynchronně po dokončení cíle Task<TResult> .

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

Parametry

continuationAction: Action<Task<TResult>>

Akce, která se má spustit po Task<TResult> dokončení. Při spuštění se delegát předá dokončený úkol jako argument.

cancellationToken: CancellationToken

Token zrušení, který se předá nové úloze pokračování.

Návraty

Task

Nový úkol pokračování.

Výjimky

ObjectDisposedException

Byla Task<TResult> odstraněna.

-nebo-

cancellationToken Vytvořený CancellationTokenSource objekt byl odstraněn.

ArgumentNullException

Argument continuationAction je null.

Příklady

Následující příklad vytvoří počáteční úlohu, která používá síto Eratosthenes k výpočtu počátečních čísel mezi 1 a hodnotou zadanou uživatelem. Pole se používá k uložení informací o prvočísečích. Index matice představuje číslo a hodnota elementu označuje, jestli je toto číslo složené (jeho hodnota je true) nebo prime (jeho hodnota je false). Tento úkol se pak předá úkolu pokračování, který je zodpovědný za extrahování prvočísek z celočíselného pole a jejich zobrazení.

Token zrušení se předá úkolu antecedent i úloze pokračování. Objekt System.Timers.Timer se používá k definování hodnoty časového limitu 100 milisekund. Pokud se událost aktivuje, CancellationTokenSource.Cancel volá se metoda a token zrušení se použije k žádosti o zrušení úkolů.

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.

Zadání hodnoty přibližně 100 000 obvykle způsobí vypršení časového limitu intervalu Timer.Elapsed a aktivaci události a nastavení žádosti o zrušení.

Poznámky

Vrácené Task úlohy nebudou naplánovány ke spuštění, dokud se nedokončil aktuální úkol, ať už se dokončí kvůli úspěšnému spuštění do dokončení, dojde k chybě kvůli neošetřené výjimce nebo se předčasně ukončí kvůli zrušení.

Viz také

Platí pro

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

Zdroj:: Future.cs

Zdroj:: Future.cs

Zdroj:: Future.cs

Vytvoří pokračování, které se předají informace o stavu a které se spustí po dokončení cíle Task<TResult> .

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

Parametry

continuationAction: Action<Task<TResult>,Object>

Akce, která se má spustit po Task<TResult> dokončení. Při spuštění se delegát předá dokončené úlohy a volajícímu objektu stavu jako argumenty.

state: Object

Objekt představující data, která mají být použita akcí pokračování.

Návraty

Task

Nové pokračování Task.

Výjimky

ArgumentNullException

Argument continuationAction je null.

Příklady

Následující příklad vytvoří úkol, který je předán celé číslo mezi 2 a 20 a vrátí matici, která obsahuje prvních deset exponentů (od n¹ do n¹⁰) tohoto čísla. Za zobrazení exponentů je pak zodpovědný úkol pokračování. Předá se antecedent i původní číslo, jehož exponenty generuje antecedent.

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

Poznámky

Viz také

Řetězení úloh pomocí úloh pokračování

Platí pro

ContinueWith(Action<Task<TResult>>)

Zdroj:: Future.cs

Zdroj:: Future.cs

Zdroj:: Future.cs

Vytvoří pokračování, které se spustí asynchronně po dokončení cílové úlohy.

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

Parametry

continuationAction: Action<Task<TResult>>

Akce, která se má spustit, když se dokončí antecedent Task<TResult> . Po spuštění se delegát předá dokončený úkol jako argument.

Návraty

Task

Nový úkol pokračování.

Výjimky

ObjectDisposedException

Byla Task<TResult> odstraněna.

ArgumentNullException

Argument continuationAction je null.

Příklady

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.

Poznámky

Vrácené Task úlohy nebudou naplánovány k provedení, dokud se aktuální úloha nedokončila, ať už se dokončí kvůli úspěšnému dokončení, dojde k chybě kvůli neošetřené výjimce nebo se předčasně ukončí kvůli zrušení.

Viz také

Platí pro

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

Zdroj:: Future.cs

Zdroj:: Future.cs

Zdroj:: Future.cs

Vytvoří pokračování, které se spustí asynchronně po dokončení cíle Task<TResult> .

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

Parametry

continuationAction: Action<Task<TResult>>

Akce, která se má spustit po Task<TResult> dokončení. Po spuštění se delegát předá dokončený úkol jako argument.

scheduler: TaskScheduler

Objekt TaskScheduler , který se má přidružit k úloze pokračování a použít k jeho provedení.

Návraty

Task

Nové pokračování Task.

Výjimky

ObjectDisposedException

Byla Task<TResult> odstraněna.

ArgumentNullException

Argument continuationAction je null.

-nebo-

Argument scheduler je null.

Poznámky

Viz také

Platí pro

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

Zdroj:: Future.cs

Zdroj:: Future.cs

Zdroj:: Future.cs

Vytvoří pokračování, které se spustí po dokončení cíle Task<TResult> .

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)

Parametry typu

TNewResult

Typ výsledku vytvořeného pokračováním.

Parametry

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

Funkce, která se spustí po Task<TResult> dokončení. Při spuštění se delegátu předá dokončená úloha a volajícím zadaný objekt stavu jako argumenty.

state: Object

Objekt představující data, která mají být použita pokračovací funkcí.

cancellationToken: CancellationToken

Hodnota CancellationToken , která bude přiřazena k novému úkolu.

continuationOptions: TaskContinuationOptions

Možnosti, kdy je pokračování naplánované a jak se chová. To zahrnuje kritéria, jako OnlyOnCanceledje , a také možnosti spuštění, jako ExecuteSynchronouslyje .

scheduler: TaskScheduler

Objekt TaskScheduler , který se má přidružit k úloze pokračování a použít k jeho provedení.

Návraty

Task<TNewResult>

Nové pokračování Task<TResult>.

Výjimky

ArgumentNullException

Argument scheduler je null.

ArgumentOutOfRangeException

Argument continuationOptions určuje neplatnou hodnotu pro TaskContinuationOptions.

ObjectDisposedException

Poskytnutá hodnota CancellationToken již byla odstraněna.

Poznámky

Vrácené Task<TResult> úlohy nebudou naplánovány ke spuštění, dokud se nedokončil aktuální úkol, ať už se dokončí kvůli úspěšnému spuštění do dokončení, dojde k chybě kvůli neošetřené výjimce nebo se předčasně ukončí kvůli zrušení.

Při continuationFunctionspuštění by měl vrátit Task<TResult>. Stav dokončení tohoto úkolu se přenese na úkol vrácený z Task<TResult>.ContinueWith volání.

Viz také

Řetězení úloh pomocí úloh pokračování

Platí pro

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

Zdroj:: Future.cs

Zdroj:: Future.cs

Zdroj:: Future.cs

Vytvoří pokračování, které se spustí podle podmínky zadané v 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)

Parametry typu

TNewResult

Typ výsledku vytvořeného pokračováním.

Parametry

continuationFunction: Func<Task<TResult>,TNewResult>

Funkce, která se spustí v souladu s podmínkou zadanou v continuationOptions.

Při spuštění se delegát předá jako argument pro tuto dokončenou úlohu.

cancellationToken: CancellationToken

Hodnota CancellationToken , která bude přiřazena k novému úkolu.

continuationOptions: TaskContinuationOptions

Možnosti, kdy je pokračování naplánované a jak se chová. To zahrnuje kritéria, jako OnlyOnCanceledje , a také možnosti spuštění, jako ExecuteSynchronouslyje .

scheduler: TaskScheduler

Chcete-li TaskScheduler přidružit úlohu pokračování a použít k jeho provedení.

Návraty

Task<TNewResult>

Nové pokračování Task<TResult>.

Výjimky

ObjectDisposedException

Byla Task<TResult> zlikvidována.

-nebo-

cancellationToken Vytvořený objekt CancellationTokenSource již byl odstraněn.

ArgumentNullException

Argument continuationFunction je null.

-nebo-

Argument scheduler je null.

ArgumentOutOfRangeException

Argument continuationOptions určuje neplatnou hodnotu pro TaskContinuationOptions.

Poznámky

Vrácené Task<TResult> úlohy nebudou naplánovány spuštění, dokud se nedokončí aktuální úloha, ať už se dokončí z důvodu úspěšného spuštění do dokončení, selhání kvůli neošetřené výjimce nebo předčasné ukončení z důvodu zrušení.

Při continuationFunctionspuštění by měl vrátit Task<TResult>.

Viz také

Platí pro

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

Zdroj:: Future.cs

Zdroj:: Future.cs

Zdroj:: Future.cs

Vytvoří pokračování, které se spustí po dokončení cíle Task<TResult> .

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)

Parametry typu

TNewResult

Typ výsledku vytvořeného pokračováním.

Parametry

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

Funkce, která se spustí po Task<TResult> dokončení. Při spuštění se delegát předá dokončené úloze a volajícímu objektu stavu jako argumenty.

state: Object

Objekt představující data, která má být použita funkcí pokračování.

scheduler: TaskScheduler

Chcete-li TaskScheduler přidružit úlohu pokračování a použít k jeho provedení.

Návraty

Task<TNewResult>

Nové pokračování Task<TResult>.

Výjimky

ArgumentNullException

Argument scheduler je null.

Poznámky

Viz také

Řetězení úloh pomocí úloh pokračování

Platí pro

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

Zdroj:: Future.cs

Zdroj:: Future.cs

Zdroj:: Future.cs

Vytvoří pokračování, které se spustí po dokončení cíle Task<TResult> .

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)

Parametry typu

TNewResult

Typ výsledku vytvořeného pokračováním.

Parametry

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

Funkce, která se spustí po Task<TResult> dokončení. Při spuštění se delegát předá dokončené úloze a volajícímu objektu stavu jako argumenty.

state: Object

Objekt představující data, která má být použita funkcí pokračování.

cancellationToken: CancellationToken

Hodnota CancellationToken , která bude přiřazena k novému úkolu.

Návraty

Task<TNewResult>

Nové pokračování Task<TResult>.

Výjimky

ArgumentNullException

Argument continuationFunction je null.

ObjectDisposedException

Poskytnutý soubor CancellationToken již byl odstraněn.

Poznámky

Viz také

Řetězení úloh pomocí úloh pokračování

Platí pro

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

Zdroj:: Future.cs

Zdroj:: Future.cs

Zdroj:: Future.cs

Vytvoří pokračování, které se spustí po dokončení cíle Task<TResult> .

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)

Parametry typu

TNewResult

Typ výsledku vytvořeného pokračováním.

Parametry

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

Funkce, která se spustí po Task<TResult> dokončení. Při spuštění se delegát předá dokončené úloze a volajícímu objektu stavu jako argumenty.

state: Object

Objekt představující data, která má být použita funkcí pokračování.

continuationOptions: TaskContinuationOptions

Možnosti, kdy je pokračování naplánované a jak se chová. To zahrnuje kritéria, jako OnlyOnCanceledje , a také možnosti spuštění, jako ExecuteSynchronouslyje .

Návraty

Task<TNewResult>

Nové pokračování Task<TResult>.

Výjimky

ArgumentNullException

Argument continuationFunction je null.

ArgumentOutOfRangeException

Argument continuationOptions určuje neplatnou hodnotu pro TaskContinuationOptions.

Poznámky

Při continuationFunctionspuštění by měl vrátit Task<TResult>. Stav dokončení tohoto úkolu se přenese na úkol vrácený z volání ContinueWith.

Viz také

Řetězení úloh pomocí úloh pokračování

Platí pro

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

Zdroj:: Future.cs

Zdroj:: Future.cs

Zdroj:: Future.cs

Vytvoří pokračování, které se spustí podle podmínky zadané v 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)

Parametry typu

TNewResult

Typ výsledku vytvořeného pokračováním.

Parametry

continuationFunction: Func<Task<TResult>,TNewResult>

Funkce, která se spustí v souladu s podmínkou zadanou v continuationOptions.

Při spuštění se delegát předá dokončený úkol jako argument.

continuationOptions: TaskContinuationOptions

Možnosti, kdy je pokračování naplánované a jak se chová. To zahrnuje kritéria, jako OnlyOnCanceledje , a také možnosti spuštění, jako ExecuteSynchronouslyje .

Návraty

Task<TNewResult>

Nové pokračování Task<TResult>.

Výjimky

ObjectDisposedException

Byla Task<TResult> zlikvidována.

ArgumentNullException

Argument continuationFunction je null.

ArgumentOutOfRangeException

Argument continuationOptions určuje neplatnou hodnotu pro TaskContinuationOptions.

Poznámky

Při continuationFunctionspuštění by měl vrátit Task<TResult>.

Viz také

Platí pro

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

Zdroj:: Future.cs

Zdroj:: Future.cs

Zdroj:: Future.cs

Vytvoří pokračování, které se spustí asynchronně po dokončení cíle Task<TResult> .

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)

Parametry typu

TNewResult

Typ výsledku vytvořeného pokračováním.

Parametry

continuationFunction: Func<Task<TResult>,TNewResult>

Funkce, která se spustí po Task<TResult> dokončení. Při spuštění se delegát předá dokončený úkol jako argument.

cancellationToken: CancellationToken

Hodnota CancellationToken , která bude přiřazena k novému úkolu.

Návraty

Task<TNewResult>

Nové pokračování Task<TResult>.

Výjimky

ObjectDisposedException

Byla Task<TResult> zlikvidována.

-nebo-

cancellationToken Vytvořený objekt CancellationTokenSource již byl odstraněn.

ArgumentNullException

Argument continuationFunction je null.

Poznámky

Viz také

Platí pro

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

Zdroj:: Future.cs

Zdroj:: Future.cs

Zdroj:: Future.cs

Vytvoří pokračování, které se spustí po dokončení cíle Task<TResult> .

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)

Parametry typu

TNewResult

Typ výsledku vytvořeného pokračováním.

Parametry

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

Funkce, která se spustí po Task<TResult> dokončení. Při spuštění se delegát předá dokončené úloze a volajícímu objektu stavu jako argumenty.

state: Object

Objekt představující data, která má být použita funkcí pokračování.

Návraty

Task<TNewResult>

Nové pokračování Task<TResult>.

Výjimky

ArgumentNullException

Argument continuationFunction je null.

Příklady

Následující příklad vytvoří řetězec úloh pokračování. Každý úkol poskytuje aktuální čas, DateTime objekt, pro argument ContinueWith(Action<Task,Object>, Object) stavu metody. Každá DateTime hodnota představuje čas, ve kterém je vytvořen pokračující úkol. Každý úkol vytvoří jako výsledek druhou DateTime hodnotu, která představuje čas dokončení úkolu. Po dokončení všech úkolů se v příkladu zobrazí datum a čas zahájení a dokončení každého úkolu pokračování.

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.

Poznámky

Viz také

Řetězení úloh pomocí úloh pokračování

Platí pro

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

Zdroj:: Future.cs

Zdroj:: Future.cs

Zdroj:: Future.cs

Vytvoří pokračování, které se spustí asynchronně po dokončení cíle Task<TResult> .

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)

Parametry typu

TNewResult

Typ výsledku vytvořeného pokračováním.

Parametry

continuationFunction: Func<Task<TResult>,TNewResult>

Funkce, která se spustí po Task<TResult> dokončení. Při spuštění se delegát předá dokončený úkol jako argument.

Návraty

Task<TNewResult>

Nové pokračování Task<TResult>.

Výjimky

ObjectDisposedException

Byla Task<TResult> zlikvidována.

ArgumentNullException

Argument continuationFunction je null.

Poznámky

Viz také

Platí pro

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

Zdroj:: Future.cs

Zdroj:: Future.cs

Zdroj:: Future.cs

Vytvoří pokračování, které se spustí asynchronně po dokončení cíle Task<TResult> .

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)

Parametry typu

TNewResult

Typ výsledku vytvořeného pokračováním.

Parametry

continuationFunction: Func<Task<TResult>,TNewResult>

Funkce, která se spustí po Task<TResult> dokončení. Při spuštění se delegát předá dokončený úkol jako argument.

scheduler: TaskScheduler

Chcete-li TaskScheduler přidružit úlohu pokračování a použít k jeho provedení.

Návraty

Task<TNewResult>

Nové pokračování Task<TResult>.

Výjimky

ObjectDisposedException

Byla Task<TResult> zlikvidována.

ArgumentNullException

Argument continuationFunction je null.

-nebo-

Argument scheduler je null.

Poznámky

Viz také

Platí pro

Sdílet prostřednictvím

Task<TResult>.ContinueWith Metoda

Definice

Přetížení

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

Parametry

Návraty

Výjimky

Poznámky

Viz také

Platí pro

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

Parametry

Návraty

Výjimky

Poznámky

Viz také

Platí pro

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

Parametry

Návraty

Výjimky

Poznámky

Viz také

Platí pro

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

Parametry

Návraty

Výjimky

Poznámky

Viz také

Platí pro

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

Parametry

Návraty

Výjimky

Poznámky

Viz také

Platí pro

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

Parametry

Návraty

Výjimky

Poznámky

Viz také

Platí pro

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

Parametry

Návraty

Výjimky

Příklady

Poznámky

Viz také

Platí pro

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

Parametry

Návraty

Výjimky

Příklady

Poznámky

Viz také

Platí pro

ContinueWith(Action<Task<TResult>>)

Parametry

Návraty

Výjimky

Příklady

Poznámky

Viz také

Platí pro

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

Parametry

Návraty

Výjimky

Poznámky

Viz také

Platí pro

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

Parametry typu

Parametry