Task.ContinueWith Metoda

Odwołanie

Definicja

Przestrzeń nazw:: System.Threading.Tasks

Zestaw:: System.Threading.Tasks.dll

Zestaw:: System.Runtime.dll

Zestaw:: mscorlib.dll

Zestaw:: netstandard.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Tworzy kontynuację wykonywaną asynchronicznie po zakończeniu celu Task .

Przeciążenia

ContinueWith(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Tworzy kontynuację, która odbiera informacje o stanie dostarczonym przez obiekt wywołujący i token anulowania oraz jest wykonywana po zakończeniu działania obiektu docelowego Task . Kontynuacja jest wykonywana na podstawie zestawu określonych warunków i używa określonego harmonogramu.
ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Tworzy kontynuację wykonywaną, gdy zadanie docelowe konkuruje zgodnie z określonym TaskContinuationOptions. Kontynuacja odbiera token anulowania i używa określonego harmonogramu.
ContinueWith(Action<Task,Object>, Object, TaskScheduler)	Tworzy kontynuację, która odbiera informacje o stanie dostarczone przez obiekt wywołujący i wykonuje asynchronicznie po zakończeniu działania obiektu docelowego Task . Kontynuacja używa określonego harmonogramu.
ContinueWith(Action<Task,Object>, Object, TaskContinuationOptions)	Tworzy kontynuację, która odbiera informacje o stanie dostarczonego przez obiekt wywołujący i wykonuje je po zakończeniu działania obiektu docelowego Task . Kontynuacja jest wykonywana na podstawie zestawu określonych warunków.
ContinueWith(Action<Task,Object>, Object, CancellationToken)	Tworzy kontynuację, która odbiera informacje o stanie dostarczonym przez obiekt wywołujący oraz token anulowania, który jest wykonywany asynchronicznie po zakończeniu działania obiektu docelowego Task .
ContinueWith(Action<Task,Object>, Object)	Tworzy kontynuację, która odbiera informacje o stanie dostarczonego przez obiekt wywołujący i wykonuje je po zakończeniu działania obiektu docelowego Task .
ContinueWith(Action<Task>, TaskContinuationOptions)	Tworzy kontynuację wykonywaną po zakończeniu zadania docelowego zgodnie z określonym TaskContinuationOptionselementem .
ContinueWith(Action<Task>, CancellationToken)	Tworzy kontynuację, która odbiera token anulowania i wykonuje asynchronicznie po zakończeniu elementu docelowego Task .
ContinueWith(Action<Task>)	Tworzy kontynuację wykonywaną asynchronicznie po zakończeniu celu Task .
ContinueWith(Action<Task>, TaskScheduler)	Tworzy kontynuację wykonywaną asynchronicznie po zakończeniu celu Task . Kontynuacja używa określonego harmonogramu.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskContinuationOptions)	Tworzy kontynuację, która jest wykonywana na podstawie określonych opcji kontynuacji zadania po zakończeniu celu Task . Kontynuacja odbiera informacje o stanie dostarczone przez obiekt wywołujący.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Tworzy kontynuację, która jest wykonywana na podstawie określonych opcji kontynuacji zadania, gdy element docelowy Task zakończy działanie i zwróci wartość. Kontynuacja odbiera informacje o stanie dostarczone przez obiekt wywołujący i token anulowania i używa określonego harmonogramu.
ContinueWith<TResult>(Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Tworzy kontynuację wykonywaną zgodnie z określonymi opcjami kontynuacji i zwraca wartość. Kontynuacja jest przekazywana token anulowania i używa określonego harmonogramu.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskScheduler)	Tworzy kontynuację wykonywaną asynchronicznie po zakończeniu celu Task . Kontynuacja odbiera informacje o stanie dostarczone przez obiekt wywołujący i używa określonego harmonogramu.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken)	Tworzy kontynuację, która jest wykonywana asynchronicznie po zakończeniu obiektu docelowego Task i zwraca wartość. Kontynuacja odbiera informacje o stanie dostarczone przez obiekt wywołujący i token anulowania.
ContinueWith<TResult>(Func<Task,TResult>, CancellationToken)	Tworzy kontynuację, która jest wykonywana asynchronicznie po zakończeniu obiektu docelowego Task i zwraca wartość. Kontynuacja otrzymuje token anulowania.
ContinueWith<TResult>(Func<Task,TResult>, TaskContinuationOptions)	Tworzy kontynuację wykonywaną zgodnie z określonymi opcjami kontynuacji i zwraca wartość.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object)	Tworzy kontynuację, która odbiera informacje o stanie dostarczone przez obiekt wywołujący i wykonuje asynchronicznie, gdy element docelowy Task zakończy i zwróci wartość.
ContinueWith<TResult>(Func<Task,TResult>)	Tworzy kontynuację, która jest wykonywana asynchronicznie po zakończeniu obiektu docelowego Task<TResult> i zwraca wartość.
ContinueWith<TResult>(Func<Task,TResult>, TaskScheduler)	Tworzy kontynuację, która jest wykonywana asynchronicznie po zakończeniu obiektu docelowego Task i zwraca wartość. Kontynuacja używa określonego harmonogramu.

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

Źródło:: Task.cs

Źródło:: Task.cs

Źródło:: Task.cs

Tworzy kontynuację, która odbiera informacje o stanie dostarczonym przez obiekt wywołujący i token anulowania oraz jest wykonywana po zakończeniu działania obiektu docelowego Task . Kontynuacja jest wykonywana na podstawie zestawu określonych warunków i używa określonego harmonogramu.

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>

Akcja do uruchomienia po zakończeniu Task . Po uruchomieniu delegat zostanie przekazany ukończone zadanie i obiekt stanu dostarczonego przez obiekt wywołujący jako argumenty.

state: Object

Obiekt reprezentujący dane, które mają być używane przez akcję kontynuacji.

cancellationToken: CancellationToken

Element CancellationToken , który zostanie przypisany do nowego zadania kontynuacji.

continuationOptions: TaskContinuationOptions

Opcje, kiedy kontynuacja jest zaplanowana i jak się zachowuje. Obejmuje to kryteria, takie jak OnlyOnCanceled, a także opcje wykonywania, takie jak ExecuteSynchronously.

scheduler: TaskScheduler

Element TaskScheduler do skojarzenia z zadaniem kontynuacji i do użycia do jego wykonania.

Zwraca

Task

Nowa kontynuacja Task.

Wyjątki

ArgumentNullException

Argumentem scheduler jest null.

ArgumentOutOfRangeException

Argument continuationOptions określa nieprawidłową wartość dla TaskContinuationOptionselementu .

ObjectDisposedException

Dostarczone CancellationToken zostało już usunięte.

Uwagi

Zwrócony Task element nie zostanie zaplanowany do wykonania do momentu ukończenia bieżącego zadania. Jeśli kryteria określone za pośrednictwem parametru continuationOptions nie zostaną spełnione, zadanie kontynuacji zostanie anulowane zamiast zaplanowane.

Dotyczy

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

Źródło:: Task.cs

Źródło:: Task.cs

Źródło:: Task.cs

Tworzy kontynuację wykonywaną, gdy zadanie docelowe konkuruje zgodnie z określonym TaskContinuationOptions. Kontynuacja odbiera token anulowania i używa określonego harmonogramu.

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>

Akcja do uruchomienia zgodnie z określonym continuationOptionselementem . Po uruchomieniu delegat zostanie przekazany ukończone zadanie jako argument.

cancellationToken: CancellationToken

Element CancellationToken , który zostanie przypisany do nowego zadania kontynuacji.

continuationOptions: TaskContinuationOptions

Opcje, kiedy kontynuacja jest zaplanowana i jak się zachowuje. Obejmuje to kryteria, takie jak OnlyOnCanceled, a także opcje wykonywania, takie jak ExecuteSynchronously.

scheduler: TaskScheduler

Element TaskScheduler do skojarzenia z zadaniem kontynuacji i do użycia do jego wykonania.

Zwraca

Task

Nowa kontynuacja Task.

Wyjątki

ObjectDisposedException

Utworzony CancellationTokenSource token został już usunięty.

ArgumentNullException

Argument continuationAction ma wartość null.

-lub-

Argument scheduler ma wartość null.

ArgumentOutOfRangeException

Argument continuationOptions określa nieprawidłową wartość dla TaskContinuationOptionselementu .

Przykłady

Poniżej przedstawiono przykład użycia funkcji ContinueWith do uruchamiania pracy zarówno w tle, jak i w wątkach interfejsu użytkownika.

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

Uwagi

Dotyczy

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

Źródło:: Task.cs

Źródło:: Task.cs

Źródło:: Task.cs

Tworzy kontynuację, która odbiera informacje o stanie dostarczone przez obiekt wywołujący i wykonuje asynchronicznie po zakończeniu działania obiektu docelowego Task . Kontynuacja używa określonego harmonogramu.

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>

Akcja do uruchomienia po zakończeniu Task . Po uruchomieniu delegat zostanie przekazany ukończone zadanie i obiekt stanu dostarczonego przez obiekt wywołujący jako argumenty.

state: Object

Obiekt reprezentujący dane, które mają być używane przez akcję kontynuacji.

scheduler: TaskScheduler

Element do skojarzenia TaskScheduler z zadaniem kontynuacji i do użycia do jego wykonania.

Zwraca

Task

Nowa kontynuacja Task.

Wyjątki

ArgumentNullException

Argumentem scheduler jest null.

Uwagi

Zwrócony Task element nie zostanie zaplanowany do wykonania do momentu ukończenia bieżącego zadania, tego, czy zostanie ukończone z powodu pomyślnego ukończenia, błędu z powodu nieobsługiwanego wyjątku lub wcześniejszego zakończenia z powodu anulowania.

Dotyczy

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

Źródło:: Task.cs

Źródło:: Task.cs

Źródło:: Task.cs

Tworzy kontynuację, która odbiera informacje o stanie dostarczone przez obiekt wywołujący i jest wykonywana po zakończeniu działania obiektu docelowego Task . Kontynuacja jest wykonywana na podstawie zestawu określonych warunków.

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>

Akcja do uruchomienia po zakończeniu Task . Po uruchomieniu delegat zostanie przekazany ukończone zadanie i obiekt stanu dostarczonego przez obiekt wywołujący jako argumenty.

state: Object

Obiekt reprezentujący dane, które mają być używane przez akcję kontynuacji.

continuationOptions: TaskContinuationOptions

Opcje dotyczące zaplanowanych kontynuacji i sposobu jej działania. Obejmuje to kryteria, takie jak OnlyOnCanceled, a także opcje wykonywania, takie jak ExecuteSynchronously.

Zwraca

Task

Nowa kontynuacja Task.

Wyjątki

ArgumentNullException

Argumentem continuationAction jest null.

ArgumentOutOfRangeException

Argument continuationOptions określa nieprawidłową wartość dla elementu TaskContinuationOptions.

Uwagi

Zwrócony Task element nie zostanie zaplanowany do wykonania do momentu ukończenia bieżącego zadania. Jeśli kryteria kontynuacji określone za pomocą parametru continuationOptions nie zostaną spełnione, zadanie kontynuacji zostanie anulowane zamiast zaplanowane.

Dotyczy

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

Źródło:: Task.cs

Źródło:: Task.cs

Źródło:: Task.cs

Tworzy kontynuację, która odbiera informacje o stanie dostarczonym przez obiekt wywołujący oraz token anulowania, który jest wykonywany asynchronicznie po zakończeniu działania obiektu docelowego 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>

Akcja do uruchomienia po zakończeniu Task . Po uruchomieniu delegat zostanie przekazany ukończone zadanie i obiekt stanu dostarczonego przez obiekt wywołujący jako argumenty.

state: Object

Obiekt reprezentujący dane, które mają być używane przez akcję kontynuacji.

cancellationToken: CancellationToken

Element CancellationToken , który zostanie przypisany do nowego zadania kontynuacji.

Zwraca

Task

Nowa kontynuacja Task.

Wyjątki

ArgumentNullException

Argumentem continuationAction jest null.

ObjectDisposedException

Podany CancellationToken element został już usunięty.

Uwagi

Dotyczy

ContinueWith(Action<Task,Object>, Object)

Źródło:: Task.cs

Źródło:: Task.cs

Źródło:: Task.cs

Tworzy kontynuację, która odbiera informacje o stanie dostarczone przez obiekt wywołujący i jest wykonywana po zakończeniu działania obiektu docelowego 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>

Akcja do uruchomienia po zakończeniu zadania. Po uruchomieniu delegat jest przekazywany do ukończonego zadania i obiekt stanu dostarczonego przez obiekt wywołujący jako argumenty.

state: Object

Obiekt reprezentujący dane, które mają być używane przez akcję kontynuacji.

Zwraca

Task

Nowe zadanie kontynuacji.

Wyjątki

ArgumentNullException

Argumentem continuationAction jest null.

Uwagi

Dotyczy

ContinueWith(Action<Task>, TaskContinuationOptions)

Źródło:: Task.cs

Źródło:: Task.cs

Źródło:: Task.cs

Tworzy kontynuację wykonywaną po zakończeniu zadania docelowego zgodnie z określonym TaskContinuationOptions.

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>

Akcja do uruchomienia zgodnie z określonym continuationOptions. Po uruchomieniu delegat zostanie przekazany ukończone zadanie jako argument.

continuationOptions: TaskContinuationOptions

Opcje dotyczące zaplanowanych kontynuacji i sposobu jej działania. Obejmuje to kryteria, takie jak OnlyOnCanceled, a także opcje wykonywania, takie jak ExecuteSynchronously.

Zwraca

Task

Nowa kontynuacja Task.

Wyjątki

ArgumentNullException

Argument continuationAction ma wartość null.

ArgumentOutOfRangeException

Argument continuationOptions określa nieprawidłową wartość dla elementu TaskContinuationOptions.

Przykłady

W poniższym przykładzie pokazano użycie metody , TaskContinuationOptions aby określić, że zadanie kontynuacji powinno być uruchamiane synchronicznie po zakończeniu zadania przedziębienia. (Jeśli określone zadanie zostało już ukończone w czasie ContinueWith jest wywoływane, kontynuacja synchroniczna zostanie uruchomiona w wywołaniu ContinueWithwątku ).

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

Uwagi

Dotyczy

ContinueWith(Action<Task>, CancellationToken)

Źródło:: Task.cs

Źródło:: Task.cs

Źródło:: Task.cs

Tworzy kontynuację, która odbiera token anulowania i wykonuje asynchronicznie po zakończeniu działania obiektu docelowego 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>

Akcja do uruchomienia po zakończeniu Task . Po uruchomieniu delegat zostanie przekazany ukończone zadanie jako argument.

cancellationToken: CancellationToken

Element CancellationToken , który zostanie przypisany do nowego zadania kontynuacji.

Zwraca

Task

Nowa kontynuacja Task.

Wyjątki

ObjectDisposedException

Utworzony CancellationTokenSource token został już usunięty.

ArgumentNullException

Argument continuationAction ma wartość null.

Uwagi

Dotyczy

ContinueWith(Action<Task>)

Źródło:: Task.cs

Źródło:: Task.cs

Źródło:: Task.cs

Tworzy kontynuację, która jest wykonywana asynchronicznie po zakończeniu elementu docelowego 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>

Akcja do uruchomienia po zakończeniu Task . Po uruchomieniu delegat zostanie przekazany ukończone zadanie jako argument.

Zwraca

Task

Nowa kontynuacja Task.

Wyjątki

ArgumentNullException

Argumentem continuationAction jest null.

Przykłady

W poniższym przykładzie zdefiniowano zadanie, które wypełnia tablicę 100 losowymi wartościami daty i godziny. Używa ContinueWith(Action<Task>) metody , aby wybrać najwcześniejsze i najnowsze wartości daty po pełnym wypełnieniu tablicy.

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

Ponieważ aplikacja konsolowa może zakończyć działanie przed wykonaniem zadania kontynuacji, Wait() metoda jest wywoływana, aby upewnić się, że kontynuacja zakończy wykonywanie przed końcem przykładu.

Aby zapoznać się z dodatkowym przykładem, zobacz Tworzenie łańcuchów zadań przy użyciu zadań kontynuacji.

Uwagi

Dotyczy

ContinueWith(Action<Task>, TaskScheduler)

Źródło:: Task.cs

Źródło:: Task.cs

Źródło:: Task.cs

Tworzy kontynuację, która jest wykonywana asynchronicznie po zakończeniu elementu docelowego Task . Kontynuacja używa określonego harmonogramu.

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>

Akcja do uruchomienia po zakończeniu Task . Po uruchomieniu delegat zostanie przekazany ukończone zadanie jako argument.

scheduler: TaskScheduler

Element do skojarzenia TaskScheduler z zadaniem kontynuacji i do użycia do jego wykonania.

Zwraca

Task

Nowa kontynuacja Task.

Wyjątki

ObjectDisposedException

Element Task został usunięty.

ArgumentNullException

Argumentem continuationAction jest null.

-lub-

Argument scheduler ma wartość null.

Uwagi

Dotyczy

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

Źródło:: Task.cs

Źródło:: Task.cs

Źródło:: Task.cs

Tworzy kontynuację, która jest wykonywana na podstawie określonych opcji kontynuacji zadania po zakończeniu elementu docelowego Task . Kontynuacja odbiera informacje o stanie dostarczone przez obiekt wywołujący.

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 wyniku wygenerowanego przez kontynuację.

Parametry

continuationFunction: Func<Task,Object,TResult>

Funkcja uruchamiana po zakończeniu Task . Po uruchomieniu delegat zostanie przekazany ukończone zadanie i obiekt stanu dostarczonego przez obiekt wywołujący jako argumenty.

state: Object

Obiekt reprezentujący dane, które mają być używane przez funkcję kontynuacji.

continuationOptions: TaskContinuationOptions

Opcje dotyczące zaplanowanych kontynuacji i sposobu jej działania. Obejmuje to kryteria, takie jak OnlyOnCanceled, a także opcje wykonywania, takie jak ExecuteSynchronously.

Zwraca

Task<TResult>

Nowa kontynuacja Task<TResult>.

Wyjątki

ArgumentNullException

Argumentem continuationFunction jest null.

ArgumentOutOfRangeException

Argument continuationOptions określa nieprawidłową wartość dla elementu TaskContinuationOptions.

Uwagi

Zwrócony Task<TResult> element nie zostanie zaplanowany do wykonania do momentu ukończenia bieżącego zadania. Jeśli kryteria kontynuacji określone za pomocą parametru continuationOptions nie zostaną spełnione, zadanie kontynuacji zostanie anulowane zamiast zaplanowane.

Dotyczy

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

Źródło:: Task.cs

Źródło:: Task.cs

Źródło:: Task.cs

Tworzy kontynuację, która jest wykonywana na podstawie określonych opcji kontynuacji zadania, gdy element docelowy Task zakończy działanie i zwróci wartość. Kontynuacja odbiera informacje o stanie dostarczone przez obiekt wywołujący i token anulowania i używa określonego harmonogramu.

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 wyniku wygenerowanego przez kontynuację.

Parametry

continuationFunction: Func<Task,Object,TResult>

Funkcja uruchamiana po zakończeniu Task . Po uruchomieniu delegat zostanie przekazany ukończone zadanie i obiekt stanu dostarczonego przez obiekt wywołujący jako argumenty.

state: Object

Obiekt reprezentujący dane, które mają być używane przez funkcję kontynuacji.

cancellationToken: CancellationToken

Element CancellationToken , który zostanie przypisany do nowego zadania kontynuacji.

continuationOptions: TaskContinuationOptions

Opcje dotyczące zaplanowanych kontynuacji i sposobu jej działania. Obejmuje to kryteria, takie jak OnlyOnCanceled, a także opcje wykonywania, takie jak ExecuteSynchronously.

scheduler: TaskScheduler

Element TaskScheduler do skojarzenia z zadaniem kontynuacji i do użycia do jego wykonania.

Zwraca

Task<TResult>

Nowa kontynuacja Task<TResult>.

Wyjątki

ArgumentNullException

Argumentem scheduler jest null.

ArgumentOutOfRangeException

Argument continuationOptions określa nieprawidłową wartość dla elementu TaskContinuationOptions.

ObjectDisposedException

Podany CancellationToken element został już usunięty.

Uwagi

Zwrócony Task<TResult> element nie zostanie zaplanowany do wykonania do momentu ukończenia bieżącego zadania. Jeśli kryteria określone za pośrednictwem parametru continuationOptions nie zostaną spełnione, zadanie kontynuacji zostanie anulowane zamiast zaplanowane.

Dotyczy

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

Źródło:: Task.cs

Źródło:: Task.cs

Źródło:: Task.cs

Tworzy kontynuację wykonywaną zgodnie z określonymi opcjami kontynuacji i zwraca wartość. Kontynuacja jest przekazywana token anulowania i używa określonego harmonogramu.

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 wyniku wygenerowanego przez kontynuację.

Parametry

continuationFunction: Func<Task,TResult>

Funkcja uruchamiana zgodnie z określonym continuationOptions. uruchomieniem, delegat zostanie przekazany ukończone zadanie jako argument.

cancellationToken: CancellationToken

Element CancellationToken , który zostanie przypisany do nowego zadania kontynuacji.

continuationOptions: TaskContinuationOptions

Opcje, kiedy kontynuacja jest zaplanowana i jak się zachowuje. Obejmuje to kryteria, takie jak OnlyOnCanceled, a także opcje wykonywania, takie jak ExecuteSynchronously.

scheduler: TaskScheduler

Element TaskScheduler do skojarzenia z zadaniem kontynuacji i do użycia do jego wykonania.

Zwraca

Task<TResult>

Nowa kontynuacja Task<TResult>.

Wyjątki

ObjectDisposedException

Został Task usunięty.

-lub-

Utworzony CancellationTokenSource token został już usunięty.

ArgumentNullException

Argument continuationFunction ma wartość null.

-lub-

Argument scheduler ma wartość null.

ArgumentOutOfRangeException

Argument continuationOptions określa nieprawidłową wartość dla TaskContinuationOptionselementu .

Przykłady

W poniższym przykładzie pokazano, jak używać metody ContinueWith z opcjami kontynuacji:

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

Uwagi

Dotyczy

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

Źródło:: Task.cs

Źródło:: Task.cs

Źródło:: Task.cs

Tworzy kontynuację wykonywaną asynchronicznie po zakończeniu celu Task . Kontynuacja odbiera informacje o stanie dostarczone przez obiekt wywołujący i używa określonego harmonogramu.

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 wyniku wygenerowanego przez kontynuację.

Parametry

continuationFunction: Func<Task,Object,TResult>

Funkcja do uruchomienia po zakończeniu Task . Po uruchomieniu delegat zostanie przekazany ukończone zadanie i obiekt stanu dostarczonego przez obiekt wywołujący jako argumenty.

state: Object

Obiekt reprezentujący dane, które mają być używane przez funkcję kontynuacji.

scheduler: TaskScheduler

Element TaskScheduler do skojarzenia z zadaniem kontynuacji i do użycia do jego wykonania.

Zwraca

Task<TResult>

Nowa kontynuacja Task<TResult>.

Wyjątki

ArgumentNullException

Argumentem scheduler jest null.

Uwagi

Zwrócony Task<TResult> element nie zostanie zaplanowany do wykonania do momentu ukończenia bieżącego zadania, niezależnie od tego, czy zostanie ukończone z powodu pomyślnego ukończenia, po awarii z powodu nieobsługiwanego wyjątku lub wcześniejszego zakończenia z powodu anulowania.

Dotyczy

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

Źródło:: Task.cs

Źródło:: Task.cs

Źródło:: Task.cs

Tworzy kontynuację, która jest wykonywana asynchronicznie po zakończeniu obiektu docelowego Task i zwraca wartość. Kontynuacja odbiera informacje o stanie dostarczone przez obiekt wywołujący i token anulowania.

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 wyniku wygenerowanego przez kontynuację.

Parametry

continuationFunction: Func<Task,Object,TResult>

Funkcja do uruchomienia po zakończeniu Task . Po uruchomieniu delegat zostanie przekazany ukończone zadanie i obiekt stanu dostarczonego przez obiekt wywołujący jako argumenty.

state: Object

Obiekt reprezentujący dane, które mają być używane przez funkcję kontynuacji.

cancellationToken: CancellationToken

Element CancellationToken , który zostanie przypisany do nowego zadania kontynuacji.

Zwraca

Task<TResult>

Nowa kontynuacja Task<TResult>.

Wyjątki

ArgumentNullException

Argumentem continuationFunction jest null.

ObjectDisposedException

Dostarczone CancellationToken zostało już usunięte.

Uwagi

Dotyczy

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

Źródło:: Task.cs

Źródło:: Task.cs

Źródło:: Task.cs

Tworzy kontynuację, która jest wykonywana asynchronicznie po zakończeniu obiektu docelowego Task i zwraca wartość. Kontynuacja otrzymuje token anulowania.

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 wyniku wygenerowanego przez kontynuację.

Parametry

continuationFunction: Func<Task,TResult>

Funkcja do uruchomienia po zakończeniu Task . Po uruchomieniu delegat zostanie przekazany ukończone zadanie jako argument.

cancellationToken: CancellationToken

Element CancellationToken , który zostanie przypisany do nowego zadania kontynuacji.

Zwraca

Task<TResult>

Nowa kontynuacja Task<TResult>.

Wyjątki

ObjectDisposedException

Został Task usunięty.

-lub-

Utworzony CancellationTokenSource token został już usunięty.

ArgumentNullException

Argument continuationFunction ma wartość null.

Uwagi

Dotyczy

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

Źródło:: Task.cs

Źródło:: Task.cs

Źródło:: Task.cs

Tworzy kontynuację wykonywaną zgodnie z określonymi opcjami kontynuacji i zwraca wartość.

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 wyniku wygenerowanego przez kontynuację.

Parametry

continuationFunction: Func<Task,TResult>

Funkcja uruchamiana zgodnie z warunkiem określonym w elemecie continuationOptions. Po uruchomieniu delegat zostanie przekazany ukończone zadanie jako argument.

continuationOptions: TaskContinuationOptions

Opcje, kiedy kontynuacja jest zaplanowana i jak się zachowuje. Obejmuje to kryteria, takie jak OnlyOnCanceled, a także opcje wykonywania, takie jak ExecuteSynchronously.

Zwraca

Task<TResult>

Nowa kontynuacja Task<TResult>.

Wyjątki

ObjectDisposedException

Został Task usunięty.

ArgumentNullException

Argument continuationFunction ma wartość null.

ArgumentOutOfRangeException

Argument continuationOptions określa nieprawidłową wartość dla TaskContinuationOptionselementu .

Uwagi

Zwrócony Task<TResult> element nie zostanie zaplanowany do wykonania do momentu ukończenia bieżącego zadania. Jeśli kryteria kontynuacji określone za pośrednictwem parametru continuationOptions nie zostaną spełnione, zadanie kontynuacji zostanie anulowane zamiast zaplanowane.

Dotyczy

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

Źródło:: Task.cs

Źródło:: Task.cs

Źródło:: Task.cs

Tworzy kontynuację, która odbiera informacje o stanie dostarczone przez obiekt wywołujący i wykonuje asynchronicznie, gdy element docelowy Task zakończy i zwróci wartość.

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 wyniku wygenerowanego przez kontynuację.

Parametry

continuationFunction: Func<Task,Object,TResult>

Funkcja do uruchomienia po zakończeniu Task . Po uruchomieniu delegat zostanie przekazany ukończone zadanie i obiekt stanu dostarczonego przez obiekt wywołujący jako argumenty.

state: Object

Obiekt reprezentujący dane, które mają być używane przez funkcję kontynuacji.

Zwraca

Task<TResult>

Nowa kontynuacja Task<TResult>.

Wyjątki

ArgumentNullException

Argumentem continuationFunction jest null.

Uwagi

Dotyczy

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

Źródło:: Task.cs

Źródło:: Task.cs

Źródło:: Task.cs

Tworzy kontynuację, która jest wykonywana asynchronicznie po zakończeniu obiektu docelowego Task<TResult> i zwraca wartość.

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 wyniku wygenerowanego przez kontynuację.

Parametry

continuationFunction: Func<Task,TResult>

Funkcja do uruchomienia po zakończeniu Task<TResult> . Po uruchomieniu delegat zostanie przekazany ukończone zadanie jako argument.

Zwraca

Task<TResult>

Nowe zadanie kontynuacji.

Wyjątki

ObjectDisposedException

Został Task usunięty.

ArgumentNullException

Argument continuationFunction ma wartość null.

Przykłady

W poniższym przykładzie pokazano, jak używać metody 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

Uwagi

Dotyczy

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

Źródło:: Task.cs

Źródło:: Task.cs

Źródło:: Task.cs

Tworzy kontynuację, która jest wykonywana asynchronicznie po zakończeniu obiektu docelowego Task i zwraca wartość. Kontynuacja używa określonego harmonogramu.

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 wyniku wygenerowanego przez kontynuację.

Parametry

continuationFunction: Func<Task,TResult>

Funkcja do uruchomienia po zakończeniu Task . Po uruchomieniu delegat zostanie przekazany ukończone zadanie jako argument.

scheduler: TaskScheduler

Element TaskScheduler do skojarzenia z zadaniem kontynuacji i do użycia do jego wykonania.

Zwraca

Task<TResult>

Nowa kontynuacja Task<TResult>.

Wyjątki

ObjectDisposedException

Został Task usunięty.

ArgumentNullException

Argument continuationFunction ma wartość null.

-lub-

Argument scheduler ma wartość null.

Uwagi

Dotyczy