Sdílet prostřednictvím

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

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

Přetížení

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

Vytvoří pokračování, které obdrží informace o stavu zadané volajícím a token zrušení a který se spustí po dokončení cíle Task . Pokračování se provádí na základě sady zadaných podmínek a používá zadaný plánovač.
ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Vytvoří pokračování, které se spustí, když cílová úloha konkuruje podle zadaného TaskContinuationOptions. Pokračování obdrží token zrušení a použije zadaný plánovač.
ContinueWith(Action<Task,Object>, Object, TaskScheduler)

Vytvoří pokračování, které obdrží informace o stavu zadané volajícím a provede asynchronně po dokončení cíle Task . Pokračování používá zadaný plánovač.
ContinueWith(Action<Task,Object>, Object, TaskContinuationOptions)

Vytvoří pokračování, které obdrží informace o stavu zadané volajícím a spustí se po dokončení cíle Task . Pokračování se spustí na základě sady zadaných podmínek.
ContinueWith(Action<Task,Object>, Object, CancellationToken)

Vytvoří pokračování, které obdrží informace o stavu zadané volajícím a token zrušení a který se spustí asynchronně po dokončení cíle Task .
ContinueWith(Action<Task>)

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

Vytvoří pokračování, které se spustí po dokončení cílové úlohy podle zadaného TaskContinuationOptionsobjektu .
ContinueWith(Action<Task>, CancellationToken)

Vytvoří pokračování, které obdrží token zrušení a provede se asynchronně po dokončení cíle Task .
ContinueWith(Action<Task,Object>, Object)

Vytvoří pokračování, které obdrží informace o stavu zadané volajícím a spustí se po dokončení cíle Task .
ContinueWith(Action<Task>, TaskScheduler)

Vytvoří pokračování, které se spustí asynchronně po dokončení cíle Task . Pokračování používá zadaný plánovač.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskScheduler)

Vytvoří pokračování, které se spustí asynchronně po dokončení cíle Task . Pokračování obdrží informace o stavu zadané volajícím a používá zadaný plánovač.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)

Vytvoří pokračování, které se spustí na základě zadaných možností pokračování úkolu, když cíl Task dokončí a vrátí hodnotu. Pokračování obdrží informace o stavu zadané volajícím a token zrušení a použije zadaný plánovač.
ContinueWith<TResult>(Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Vytvoří pokračování, které se spustí podle zadaných možností pokračování a vrátí hodnotu. Pokračování se předá token zrušení a použije zadaný plánovač.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken)

Vytvoří pokračování, které se spustí asynchronně, když se cíl Task dokončí a vrátí hodnotu. Pokračování obdrží informace o stavu zadané volajícím a token zrušení.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskContinuationOptions)

Vytvoří pokračování, které se spustí na základě zadaných možností pokračování úkolu po dokončení cíle Task . Pokračování obdrží informace o stavu zadané volajícím.
ContinueWith<TResult>(Func<Task,TResult>, TaskContinuationOptions)

Vytvoří pokračování, které se spustí podle zadaných možností pokračování a vrátí hodnotu.
ContinueWith<TResult>(Func<Task,TResult>, TaskScheduler)

Vytvoří pokračování, které se spustí asynchronně, když se cíl Task dokončí a vrátí hodnotu. Pokračování používá zadaný plánovač.
ContinueWith<TResult>(Func<Task,TResult>, CancellationToken)

Vytvoří pokračování, které se spustí asynchronně, když se cíl Task dokončí a vrátí hodnotu. Pokračování obdrží token zrušení.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object)

Vytvoří pokračování, které přijímá informace o stavu zadané volajícím a provádí asynchronně, když cíl Task dokončí a vrátí hodnotu.
ContinueWith<TResult>(Func<Task,TResult>)

Vytvoří pokračování, které se spustí asynchronně, když se cíl Task<TResult> dokončí a vrátí hodnotu.

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

Zdroj:
Task.cs
Zdroj:
Task.cs
Zdroj:
Task.cs

Vytvoří pokračování, které obdrží informace o stavu zadané volajícím a token zrušení a který se spustí po dokončení cíle Task . Pokračování se provádí na základě sady zadaných podmínek a používá zadaný plánovač.

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^, System::Object ^> ^ continuationAction, System::Object ^ state, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskContinuationOptions continuationOptions, System::Threading::Tasks::TaskScheduler ^ scheduler);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object> continuationAction, object state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object?> continuationAction, object? state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);
member this.ContinueWith : Action<System.Threading.Tasks.Task, obj> * obj * System.Threading.CancellationToken * System.Threading.Tasks.TaskContinuationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task
Public Function ContinueWith (continuationAction As Action(Of Task, Object), state As Object, cancellationToken As CancellationToken, continuationOptions As TaskContinuationOptions, scheduler As TaskScheduler) As Task

Parametry

continuationAction
Action<Task,Object>

Akce, která se spustí po Task 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.

Platí pro

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

Zdroj:
Task.cs
Zdroj:
Task.cs
Zdroj:
Task.cs

Vytvoří pokračování, které se spustí, když cílová úloha konkuruje podle zadaného TaskContinuationOptions. Pokračování obdrží token zrušení a použije zadaný plánovač.

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^> ^ continuationAction, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskContinuationOptions continuationOptions, System::Threading::Tasks::TaskScheduler ^ scheduler);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task> continuationAction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);
member this.ContinueWith : Action<System.Threading.Tasks.Task> * System.Threading.CancellationToken * System.Threading.Tasks.TaskContinuationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task
Public Function ContinueWith (continuationAction As Action(Of Task), cancellationToken As CancellationToken, continuationOptions As TaskContinuationOptions, scheduler As TaskScheduler) As Task

Parametry

continuationAction
Action<Task>

Akce, která se má spustit podle zadaného continuationOptionsparametru . 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

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

ObjectDisposedException

Token CancellationTokenSource , který token vytvořil, již byl odstraněn.

ArgumentNullException

Argument continuationAction je null.

-nebo-

Argument scheduler je null.

ArgumentOutOfRangeException

Argument continuationOptions určuje neplatnou hodnotu pro TaskContinuationOptions.

Příklady

Následuje příklad použití ContinueWith ke spuštění práce na pozadí i na vláknech uživatelského rozhraní.

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

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

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

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.

Platí pro

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

Zdroj:
Task.cs
Zdroj:
Task.cs
Zdroj:
Task.cs

Vytvoří pokračování, které přijímá informace o stavu zadané volajícím a spustí se asynchronně po dokončení cíle Task . Pokračování používá zadaný plánovač.

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^, System::Object ^> ^ continuationAction, System::Object ^ state, System::Threading::Tasks::TaskScheduler ^ scheduler);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object> continuationAction, object state, System.Threading.Tasks.TaskScheduler scheduler);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object?> continuationAction, object? state, System.Threading.Tasks.TaskScheduler scheduler);
member this.ContinueWith : Action<System.Threading.Tasks.Task, obj> * obj * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task
Public Function ContinueWith (continuationAction As Action(Of Task, Object), state As Object, scheduler As TaskScheduler) As Task

Parametry

continuationAction
Action<Task,Object>

Akce, která se má spustit po Task 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 akcí pokračování.

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

ArgumentNullException

Argument scheduler je null.

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

Platí pro

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

Zdroj:
Task.cs
Zdroj:
Task.cs
Zdroj:
Task.cs

Vytvoří pokračování, které obdrží informace o stavu zadané volajícím a spustí se po dokončení cíle Task . Pokračování se spustí na základě sady zadaných podmínek.

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^, System::Object ^> ^ continuationAction, System::Object ^ state, System::Threading::Tasks::TaskContinuationOptions continuationOptions);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object> continuationAction, object state, System.Threading.Tasks.TaskContinuationOptions continuationOptions);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object?> continuationAction, object? state, System.Threading.Tasks.TaskContinuationOptions continuationOptions);
member this.ContinueWith : Action<System.Threading.Tasks.Task, obj> * obj * System.Threading.Tasks.TaskContinuationOptions -> System.Threading.Tasks.Task
Public Function ContinueWith (continuationAction As Action(Of Task, Object), state As Object, continuationOptions As TaskContinuationOptions) As Task

Parametry

continuationAction
Action<Task,Object>

Akce, která se má spustit po Task 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 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

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.

Platí pro

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

Zdroj:
Task.cs
Zdroj:
Task.cs
Zdroj:
Task.cs

Vytvoří pokračování, které obdrží informace o stavu zadané volajícím a token zrušení a který se spustí asynchronně po dokončení cíle Task .

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^, System::Object ^> ^ continuationAction, System::Object ^ state, System::Threading::CancellationToken cancellationToken);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object> continuationAction, object state, System.Threading.CancellationToken cancellationToken);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object?> continuationAction, object? state, System.Threading.CancellationToken cancellationToken);
member this.ContinueWith : Action<System.Threading.Tasks.Task, obj> * obj * System.Threading.CancellationToken -> System.Threading.Tasks.Task
Public Function ContinueWith (continuationAction As Action(Of Task, Object), state As Object, cancellationToken As CancellationToken) As Task

Parametry

continuationAction
Action<Task,Object>

Akce, která se má spustit po Task 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 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á hodnota CancellationToken již byla odstraněna.

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

Platí pro

ContinueWith(Action<Task>)

Zdroj:
Task.cs
Zdroj:
Task.cs
Zdroj:
Task.cs

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

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^> ^ continuationAction);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task> continuationAction);
member this.ContinueWith : Action<System.Threading.Tasks.Task> -> System.Threading.Tasks.Task
Public Function ContinueWith (continuationAction As Action(Of Task)) As Task

Parametry

continuationAction
Action<Task>

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

Návraty

Task

Nové pokračování Task.

Výjimky

ArgumentNullException

Argument continuationAction je null.

Příklady

Následující příklad definuje úlohu, která naplní pole 100 náhodnými hodnotami data a času. Používá metodu ContinueWith(Action<Task>) k výběru nejstarších a nejnovějších hodnot data po úplném naplnění pole.

using System;
using System.Threading.Tasks;

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

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

open System
open System.Threading.Tasks

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

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

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

        dates)

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

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

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

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


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

Imports System.Threading.Tasks

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

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

Vzhledem k tomu, že konzolová aplikace může ukončit před spuštěním úlohy pokračování, Wait() je volána metoda, aby se zajistilo, že se pokračování dokončí před koncem příkladu.

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

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

Platí pro

ContinueWith(Action<Task>, TaskContinuationOptions)

Zdroj:
Task.cs
Zdroj:
Task.cs
Zdroj:
Task.cs

Vytvoří pokračování, které se spustí po dokončení cílové úlohy podle zadaného TaskContinuationOptionsobjektu .

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^> ^ continuationAction, System::Threading::Tasks::TaskContinuationOptions continuationOptions);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task> continuationAction, System.Threading.Tasks.TaskContinuationOptions continuationOptions);
member this.ContinueWith : Action<System.Threading.Tasks.Task> * System.Threading.Tasks.TaskContinuationOptions -> System.Threading.Tasks.Task
Public Function ContinueWith (continuationAction As Action(Of Task), continuationOptions As TaskContinuationOptions) As Task

Parametry

continuationAction
Action<Task>

Akce, která se má spustit podle zadaného continuationOptionsobjektu . 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

ArgumentNullException

Argument continuationAction má hodnotu null.

ArgumentOutOfRangeException

Argument continuationOptions určuje neplatnou hodnotu pro TaskContinuationOptions.

Příklady

Následující příklad ukazuje použití TaskContinuationOptions k určení, že úloha pokračování by měla běžet synchronně po dokončení hlavní úlohy. (Pokud je zadaná úloha již dokončena v době ContinueWith volání, synchronní pokračování se spustí na vlákně volající ContinueWith.)

public class TaskCounter
{
   private volatile int _count;

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

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

Public Class TaskCounter
   Private _count as Integer

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

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

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.

Platí pro

ContinueWith(Action<Task>, CancellationToken)

Zdroj:
Task.cs
Zdroj:
Task.cs
Zdroj:
Task.cs

Vytvoří pokračování, které obdrží token zrušení a spustí se asynchronně po dokončení cíle Task .

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^> ^ continuationAction, System::Threading::CancellationToken cancellationToken);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task> continuationAction, System.Threading.CancellationToken cancellationToken);
member this.ContinueWith : Action<System.Threading.Tasks.Task> * System.Threading.CancellationToken -> System.Threading.Tasks.Task
Public Function ContinueWith (continuationAction As Action(Of Task), cancellationToken As CancellationToken) As Task

Parametry

continuationAction
Action<Task>

Akce, která se má spustit po Task dokončení. Po 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í.

Návraty

Task

Nové pokračování Task.

Výjimky

ObjectDisposedException

Token CancellationTokenSource , který token vytvořil, již byl odstraněn.

ArgumentNullException

Argument continuationAction má hodnotu null.

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

Platí pro

ContinueWith(Action<Task,Object>, Object)

Zdroj:
Task.cs
Zdroj:
Task.cs
Zdroj:
Task.cs

Vytvoří pokračování, které obdrží informace o stavu zadané volajícím a spustí se po dokončení cíle Task .

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^, System::Object ^> ^ continuationAction, System::Object ^ state);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object> continuationAction, object state);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object?> continuationAction, object? state);
member this.ContinueWith : Action<System.Threading.Tasks.Task, obj> * obj -> System.Threading.Tasks.Task
Public Function ContinueWith (continuationAction As Action(Of Task, Object), state As Object) As Task

Parametry

continuationAction
Action<Task,Object>

Akce, která se má spustit po dokončení úlohy. Při spuštění se delegát předá dokončený úkol a volajícím zadaný objekt stavu jako argumenty.

state
Object

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

Návraty

Task

Nový úkol pokračování.

Výjimky

ArgumentNullException

Argument continuationAction je null.

Poznámky

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

Platí pro

ContinueWith(Action<Task>, TaskScheduler)

Zdroj:
Task.cs
Zdroj:
Task.cs
Zdroj:
Task.cs

Vytvoří pokračování, které se spustí asynchronně po dokončení cíle Task . Pokračování používá zadaný plánovač.

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^> ^ continuationAction, System::Threading::Tasks::TaskScheduler ^ scheduler);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task> continuationAction, System.Threading.Tasks.TaskScheduler scheduler);
member this.ContinueWith : Action<System.Threading.Tasks.Task> * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task
Public Function ContinueWith (continuationAction As Action(Of Task), scheduler As TaskScheduler) As Task

Parametry

continuationAction
Action<Task>

Akce, která se má spustit po Task 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 odstraněna.

ArgumentNullException

Argument continuationAction je null.

-nebo-

Argument scheduler má hodnotu null.

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

Platí pro

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

Zdroj:
Task.cs
Zdroj:
Task.cs
Zdroj:
Task.cs

Vytvoří pokračování, které se spustí asynchronně po dokončení cíle Task . Pokračování obdrží informace o stavu zadané volajícím a použije zadaný plánovač.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, System::Object ^, TResult> ^ continuationFunction, System::Object ^ state, System::Threading::Tasks::TaskScheduler ^ scheduler);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object,TResult> continuationFunction, object state, System.Threading.Tasks.TaskScheduler scheduler);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object?,TResult> continuationFunction, object? state, System.Threading.Tasks.TaskScheduler scheduler);
member this.ContinueWith : Func<System.Threading.Tasks.Task, obj, 'Result> * obj * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task<'Result>
Public Function ContinueWith(Of TResult) (continuationFunction As Func(Of Task, Object, TResult), state As Object, scheduler As TaskScheduler) As Task(Of TResult)

Parametry typu

TResult

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

Parametry

continuationFunction
Func<Task,Object,TResult>

Funkce, která se spustí po Task 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í.

scheduler
TaskScheduler

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

Návraty

Task<TResult>

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

Výjimky

ArgumentNullException

Argument scheduler je null.

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

Platí pro

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

Zdroj:
Task.cs
Zdroj:
Task.cs
Zdroj:
Task.cs

Vytvoří pokračování, které se spustí na základě zadaných možností pokračování úkolu po dokončení cíle Task a vrátí hodnotu. Pokračování obdrží informace o stavu od volajícího a token zrušení a použije zadaný plánovač.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, System::Object ^, TResult> ^ continuationFunction, System::Object ^ state, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskContinuationOptions continuationOptions, System::Threading::Tasks::TaskScheduler ^ scheduler);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object,TResult> continuationFunction, object state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object?,TResult> continuationFunction, object? state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);
member this.ContinueWith : Func<System.Threading.Tasks.Task, obj, 'Result> * obj * System.Threading.CancellationToken * System.Threading.Tasks.TaskContinuationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task<'Result>
Public Function ContinueWith(Of TResult) (continuationFunction As Func(Of Task, Object, TResult), state As Object, cancellationToken As CancellationToken, continuationOptions As TaskContinuationOptions, scheduler As TaskScheduler) As Task(Of TResult)

Parametry typu

TResult

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

Parametry

continuationFunction
Func<Task,Object,TResult>

Funkce, která se spustí po Task 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 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<TResult>

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

Platí pro

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

Zdroj:
Task.cs
Zdroj:
Task.cs
Zdroj:
Task.cs

Vytvoří pokračování, které se spustí podle zadaných možností pokračování a vrátí hodnotu. Pokračování se předá token zrušení a použije zadaný plánovač.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, TResult> ^ continuationFunction, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskContinuationOptions continuationOptions, System::Threading::Tasks::TaskScheduler ^ scheduler);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,TResult> continuationFunction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);
member this.ContinueWith : Func<System.Threading.Tasks.Task, 'Result> * System.Threading.CancellationToken * System.Threading.Tasks.TaskContinuationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task<'Result>
Public Function ContinueWith(Of TResult) (continuationFunction As Func(Of Task, TResult), cancellationToken As CancellationToken, continuationOptions As TaskContinuationOptions, scheduler As TaskScheduler) As Task(Of TResult)

Parametry typu

TResult

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

Parametry

continuationFunction
Func<Task,TResult>

Funkce, která se má spustit podle zadaného continuationOptions. při spuštění, se delegát předá dokončené úloze 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<TResult>

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

Výjimky

ObjectDisposedException

Byla Task odstraněna.

-nebo-

Token CancellationTokenSource , který token vytvořil, již byl odstraněn.

ArgumentNullException

Argument continuationFunction má hodnotu null.

-nebo-

Argument scheduler má hodnotu null.

ArgumentOutOfRangeException

Argument continuationOptions určuje neplatnou hodnotu pro TaskContinuationOptions.

Příklady

Následující příklad ukazuje, jak použít Metodu ContinueWith s možnostmi pokračování:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

let failure =
    fun () ->

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

        raise (InvalidOperationException "SIMULATED EXCEPTION")

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

let rollback =
    fun (antecendent: Task) ->

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

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

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

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

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

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

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

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

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

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

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

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

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

Imports System.Threading
Imports System.Threading.Tasks

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

Poznámky

Vrácené Task<TResult> ú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.

Platí pro

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

Zdroj:
Task.cs
Zdroj:
Task.cs
Zdroj:
Task.cs

Vytvoří pokračování, které se spustí asynchronně po dokončení cíle Task a vrátí hodnotu. Pokračování obdrží informace o stavu zadané volajícím a token zrušení.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, System::Object ^, TResult> ^ continuationFunction, System::Object ^ state, System::Threading::CancellationToken cancellationToken);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object,TResult> continuationFunction, object state, System.Threading.CancellationToken cancellationToken);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object?,TResult> continuationFunction, object? state, System.Threading.CancellationToken cancellationToken);
member this.ContinueWith : Func<System.Threading.Tasks.Task, obj, 'Result> * obj * System.Threading.CancellationToken -> System.Threading.Tasks.Task<'Result>
Public Function ContinueWith(Of TResult) (continuationFunction As Func(Of Task, Object, TResult), state As Object, cancellationToken As CancellationToken) As Task(Of TResult)

Parametry typu

TResult

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

Parametry

continuationFunction
Func<Task,Object,TResult>

Funkce, která se spustí po Task 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 pokračování.

Návraty

Task<TResult>

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

Výjimky

ArgumentNullException

Argument continuationFunction je null.

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

Platí pro

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

Zdroj:
Task.cs
Zdroj:
Task.cs
Zdroj:
Task.cs

Vytvoří pokračování, které se spustí na základě zadaných možností pokračování úkolu po dokončení cíle Task . Pokračování obdrží informace o stavu zadané volajícím.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, System::Object ^, TResult> ^ continuationFunction, System::Object ^ state, System::Threading::Tasks::TaskContinuationOptions continuationOptions);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object,TResult> continuationFunction, object state, System.Threading.Tasks.TaskContinuationOptions continuationOptions);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object?,TResult> continuationFunction, object? state, System.Threading.Tasks.TaskContinuationOptions continuationOptions);
member this.ContinueWith : Func<System.Threading.Tasks.Task, obj, 'Result> * obj * System.Threading.Tasks.TaskContinuationOptions -> System.Threading.Tasks.Task<'Result>
Public Function ContinueWith(Of TResult) (continuationFunction As Func(Of Task, Object, TResult), state As Object, continuationOptions As TaskContinuationOptions) As Task(Of TResult)

Parametry typu

TResult

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

Parametry

continuationFunction
Func<Task,Object,TResult>

Funkce, která se spustí po Task 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í.

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

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

Výjimky

ArgumentNullException

Argument continuationFunction je null.

ArgumentOutOfRangeException

Argument continuationOptions určuje neplatnou hodnotu pro TaskContinuationOptions.

Poznámky

Vrácené Task<TResult> ú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.

Platí pro

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

Zdroj:
Task.cs
Zdroj:
Task.cs
Zdroj:
Task.cs

Vytvoří pokračování, které se spustí podle zadaných možností pokračování a vrátí hodnotu.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, TResult> ^ continuationFunction, System::Threading::Tasks::TaskContinuationOptions continuationOptions);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,TResult> continuationFunction, System.Threading.Tasks.TaskContinuationOptions continuationOptions);
member this.ContinueWith : Func<System.Threading.Tasks.Task, 'Result> * System.Threading.Tasks.TaskContinuationOptions -> System.Threading.Tasks.Task<'Result>
Public Function ContinueWith(Of TResult) (continuationFunction As Func(Of Task, TResult), continuationOptions As TaskContinuationOptions) As Task(Of TResult)

Parametry typu

TResult

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

Parametry

continuationFunction
Func<Task,TResult>

Funkce, která se má spustit podle podmínky zadané 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<TResult>

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

Výjimky

ObjectDisposedException

Byla Task odstraněna.

ArgumentNullException

Argument continuationFunction má hodnotu null.

ArgumentOutOfRangeException

Argument continuationOptions určuje neplatnou hodnotu pro TaskContinuationOptions.

Poznámky

Vrácené Task<TResult> ú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.

Platí pro

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

Zdroj:
Task.cs
Zdroj:
Task.cs
Zdroj:
Task.cs

Vytvoří pokračování, které se spustí asynchronně po dokončení cíle Task a vrátí hodnotu. Pokračování používá zadaný plánovač.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, TResult> ^ continuationFunction, System::Threading::Tasks::TaskScheduler ^ scheduler);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,TResult> continuationFunction, System.Threading.Tasks.TaskScheduler scheduler);
member this.ContinueWith : Func<System.Threading.Tasks.Task, 'Result> * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task<'Result>
Public Function ContinueWith(Of TResult) (continuationFunction As Func(Of Task, TResult), scheduler As TaskScheduler) As Task(Of TResult)

Parametry typu

TResult

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

Parametry

continuationFunction
Func<Task,TResult>

Funkce, která se spustí po Task 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<TResult>

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

Výjimky

ObjectDisposedException

Byla Task odstraněna.

ArgumentNullException

Argument continuationFunction má hodnotu null.

-nebo-

Argument scheduler má hodnotu null.

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

Platí pro

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

Zdroj:
Task.cs
Zdroj:
Task.cs
Zdroj:
Task.cs

Vytvoří pokračování, které se spustí asynchronně po dokončení cíle Task a vrátí hodnotu. Pokračování obdrží token zrušení.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, TResult> ^ continuationFunction, System::Threading::CancellationToken cancellationToken);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,TResult> continuationFunction, System.Threading.CancellationToken cancellationToken);
member this.ContinueWith : Func<System.Threading.Tasks.Task, 'Result> * System.Threading.CancellationToken -> System.Threading.Tasks.Task<'Result>
Public Function ContinueWith(Of TResult) (continuationFunction As Func(Of Task, TResult), cancellationToken As CancellationToken) As Task(Of TResult)

Parametry typu

TResult

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

Parametry

continuationFunction
Func<Task,TResult>

Funkce, která se spustí po Task dokončení. Po 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í.

Návraty

Task<TResult>

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

Výjimky

ObjectDisposedException

Byla Task odstraněna.

-nebo-

Token CancellationTokenSource , který token vytvořil, již byl odstraněn.

ArgumentNullException

Argument continuationFunction má hodnotu null.

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

Platí pro

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

Zdroj:
Task.cs
Zdroj:
Task.cs
Zdroj:
Task.cs

Vytvoří pokračování, které přijímá informace o stavu zadané volajícím a spustí se asynchronně po dokončení cíle Task a vrátí hodnotu.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, System::Object ^, TResult> ^ continuationFunction, System::Object ^ state);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object,TResult> continuationFunction, object state);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object?,TResult> continuationFunction, object? state);
member this.ContinueWith : Func<System.Threading.Tasks.Task, obj, 'Result> * obj -> System.Threading.Tasks.Task<'Result>
Public Function ContinueWith(Of TResult) (continuationFunction As Func(Of Task, Object, TResult), state As Object) As Task(Of TResult)

Parametry typu

TResult

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

Parametry

continuationFunction
Func<Task,Object,TResult>

Funkce, která se spustí po Task 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í.

Návraty

Task<TResult>

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

Výjimky

ArgumentNullException

Argument continuationFunction je null.

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

Platí pro

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

Zdroj:
Task.cs
Zdroj:
Task.cs
Zdroj:
Task.cs

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

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, TResult> ^ continuationFunction);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,TResult> continuationFunction);
member this.ContinueWith : Func<System.Threading.Tasks.Task, 'Result> -> System.Threading.Tasks.Task<'Result>
Public Function ContinueWith(Of TResult) (continuationFunction As Func(Of Task, TResult)) As Task(Of TResult)

Parametry typu

TResult

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

Parametry

continuationFunction
Func<Task,TResult>

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

Návraty

Task<TResult>

Nový úkol pokračování.

Výjimky

ObjectDisposedException

Byla Task odstraněna.

ArgumentNullException

Argument continuationFunction má hodnotu null.

Příklady

Následující příklad ukazuje, jak použít Metodu ContinueWith:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Imports System.Threading
Imports System.Threading.Tasks

Module ContinuationDemo

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

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


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

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


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

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

Platí pro