Task.ContinueWith Methode

Referenz

Definition

Namespace:: System.Threading.Tasks

Assembly:: System.Threading.Tasks.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde.

Überlädt

ContinueWith(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen sowie ein Abbruchtoken empfängt und ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde. Die Fortsetzung wird entsprechend einem Satz angegebener Bedingungen ausgeführt und verwendet einen angegebenen Zeitplan.
ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Erstellt eine Fortsetzung, die, sobald die Zielaufgabe abgeschlossen ist, entsprechend den Angaben in TaskContinuationOptions ausgeführt wird. Die Fortsetzung empfängt ein Abbruchtoken und verwendet einen angegebenen Zeitplan.
ContinueWith(Action<Task,Object>, Object, TaskScheduler)	Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen empfängt, und wird asynchron ausgeführt, wenn der Ziel-Task abgeschlossen ist. Die Fortsetzung verwendet einen angegebenen Zeitplan.
ContinueWith(Action<Task,Object>, Object, TaskContinuationOptions)	Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen empfängt, und wird ausgeführt, wenn der Ziel-Task abgeschlossen ist. Die Fortsetzung wird entsprechend einem Satz angegebener Bedingungen ausgeführt.
ContinueWith(Action<Task,Object>, Object, CancellationToken)	Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen sowie ein Abbruchtoken empfängt und asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde.
ContinueWith(Action<Task>)	Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde.
ContinueWith(Action<Task>, TaskContinuationOptions)	Erstellt eine Fortsetzung, die, sobald die Zielaufgabe abgeschlossen ist, entsprechend den Angaben in TaskContinuationOptions ausgeführt wird.
ContinueWith(Action<Task>, CancellationToken)	Erstellt eine Fortsetzung, die ein Abbruchtoken empfängt und asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde.
ContinueWith(Action<Task,Object>, Object)	Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen empfängt, und wird ausgeführt, wenn der Ziel-Task abgeschlossen ist.
ContinueWith(Action<Task>, TaskScheduler)	Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde. Die Fortsetzung verwendet einen angegebenen Zeitplan.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskScheduler)	Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde. Die Fortsetzung empfängt vom Aufrufer bereitgestellte Zustandsinformationen und verwendet einen angegebenen Zeitplan.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Erstellt eine Fortsetzung, die entsprechend den angegebenen Aufgabenfortsetzungsoptionen ausgeführt wird, wenn der Ziel-Task abgeschlossen ist, und gibt einen Wert zurück. Die Fortsetzung empfängt vom Aufrufer bereitgestellte Zustandsinformationen sowie ein Abbruchtoken und verwendet den angegebenen Zeitplan.
ContinueWith<TResult>(Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Erstellt eine Fortsetzung, die entsprechend den angegebenen Fortsetzungsoptionen ausgeführt wird, und gibt einen Wert zurück. An die Fortsetzung wird ein Abbruchtoken übergeben, und sie verwendet einen angegebenen Zeitplan.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken)	Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde, und gibt einen Wert zurück. Die Fortsetzung empfängt vom Aufrufer bereitgestellte Zustandsinformationen sowie ein Abbruchtoken.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskContinuationOptions)	Erstellt eine Fortsetzung, die entsprechend den angegebenen Aufgabenfortsetzungsoptionen ausgeführt wird, wenn der Ziel-Task abgeschlossen ist. Die Fortsetzung empfängt vom Aufrufer bereitgestellte Zustandsinformationen.
ContinueWith<TResult>(Func<Task,TResult>, TaskContinuationOptions)	Erstellt eine Fortsetzung, die entsprechend den angegebenen Fortsetzungsoptionen ausgeführt wird, und gibt einen Wert zurück.
ContinueWith<TResult>(Func<Task,TResult>, TaskScheduler)	Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde, und gibt einen Wert zurück. Die Fortsetzung verwendet einen angegebenen Zeitplan.
ContinueWith<TResult>(Func<Task,TResult>, CancellationToken)	Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde, und gibt einen Wert zurück. Die Fortsetzung empfängt ein Abbruchtoken.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object)	Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen empfängt, und wird asynchron ausgeführt, wenn der Ziel-Task abgeschlossen ist, und gibt einen Wert zurück.
ContinueWith<TResult>(Func<Task,TResult>)	Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task<TResult> abgeschlossen wurde, und gibt einen Wert zurück.

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

Quelle:: Task.cs

Quelle:: Task.cs

Quelle:: Task.cs

Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen sowie ein Abbruchtoken empfängt und ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde. Die Fortsetzung wird entsprechend einem Satz angegebener Bedingungen ausgeführt und verwendet einen angegebenen Zeitplan.

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

Parameter

continuationAction: Action<Task,Object>

Eine Aktion, die beim Abschluss von Task ausgeführt werden soll. Bei der Ausführung werden dem Delegaten die abgeschlossene Aufgabe und das vom Aufrufer angegebene Zustandsobjekt als Argumente übergeben.

state: Object

Ein Objekt, das Daten darstellt, die von der Fortsetzungsaktion verwendet werden sollen.

cancellationToken: CancellationToken

Das CancellationToken, das der neuen Fortsetzungsaufgabe zugewiesen wird.

continuationOptions: TaskContinuationOptions

Optionen für die Planung und das Verhalten der Fortsetzung. Dazu zählen Kriterien wie OnlyOnCanceled und Ausführungsoptionen wie ExecuteSynchronously.

scheduler: TaskScheduler

Das TaskScheduler, das der Fortsetzungsaufgabe zugeordnet und für ihre Ausführung verwendet werden soll.

Gibt zurück

Task

Ein neuer Fortsetzungs-Task.

Ausnahmen

ArgumentNullException

Das scheduler-Argument lautet null.

ArgumentOutOfRangeException

Das continuationOptions-Argument gibt einen ungültigen Wert für TaskContinuationOptions an.

ObjectDisposedException

Das angegebene CancellationToken wurde bereits verworfen.

Hinweise

Die zurückgegebene Task wird erst dann für die Ausführung geplant, wenn der aktuelle Task abgeschlossen ist. Wenn die durch den continuationOptions Parameter angegebenen Kriterien nicht erfüllt sind, wird der Fortsetzungstask abgebrochen und nicht geplant.

Gilt für:

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

Quelle:: Task.cs

Quelle:: Task.cs

Quelle:: Task.cs

Erstellt eine Fortsetzung, die, sobald die Zielaufgabe abgeschlossen ist, entsprechend den Angaben in TaskContinuationOptions ausgeführt wird. Die Fortsetzung empfängt ein Abbruchtoken und verwendet einen angegebenen Zeitplan.

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

Parameter

continuationAction: Action<Task>

Eine Aktion, die nach den angegebenen continuationOptions ausgeführt werden soll. Bei der Ausführung wird dem Delegaten die abgeschlossene Aufgabe als Argument übergeben.

cancellationToken: CancellationToken

Das CancellationToken, das der neuen Fortsetzungsaufgabe zugewiesen wird.

continuationOptions: TaskContinuationOptions

Optionen für die Planung und das Verhalten der Fortsetzung. Dazu zählen Kriterien wie OnlyOnCanceled und Ausführungsoptionen wie ExecuteSynchronously.

scheduler: TaskScheduler

Das TaskScheduler, das der Fortsetzungsaufgabe zugeordnet und für ihre Ausführung verwendet werden soll.

Gibt zurück

Task

Ein neuer Fortsetzungs-Task.

Ausnahmen

ObjectDisposedException

Die CancellationTokenSource, die das Token erstellt hat, wurde bereits freigegeben.

ArgumentNullException

Das continuationAction-Argument ist null.

- oder -

Das scheduler-Argument ist null.

ArgumentOutOfRangeException

Das continuationOptions-Argument gibt einen ungültigen Wert für TaskContinuationOptions an.

Beispiele

Im Folgenden finden Sie ein Beispiel für die Verwendung von ContinueWith zum Ausführen von Arbeiten sowohl im Hintergrund als auch in den Benutzeroberflächenthreads.

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

Hinweise

Gilt für:

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

Quelle:: Task.cs

Quelle:: Task.cs

Quelle:: Task.cs

Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen empfängt, und wird asynchron ausgeführt, wenn der Ziel-Task abgeschlossen ist. Die Fortsetzung verwendet einen angegebenen Zeitplan.

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

Parameter

continuationAction: Action<Task,Object>

state: Object

Ein Objekt, das Daten darstellt, die von der Fortsetzungsaktion verwendet werden sollen.

scheduler: TaskScheduler

Das TaskScheduler, das der Fortsetzungsaufgabe zugeordnet und für ihre Ausführung verwendet werden soll.

Gibt zurück

Task

Ein neuer Fortsetzungs-Task.

Ausnahmen

ArgumentNullException

Das scheduler-Argument lautet null.

Hinweise

Die zurückgegebene Task wird erst für die Ausführung geplant, wenn die aktuelle Aufgabe abgeschlossen ist, unabhängig davon, ob sie aufgrund einer erfolgreichen Ausführung bis zum Abschluss, eines Fehlers aufgrund einer nicht behandelten Ausnahme oder eines vorzeitigen Beendens aufgrund eines Abbruchs abgeschlossen wird.

Gilt für:

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

Quelle:: Task.cs

Quelle:: Task.cs

Quelle:: Task.cs

Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen empfängt, und wird ausgeführt, wenn der Ziel-Task abgeschlossen ist. Die Fortsetzung wird entsprechend einem Satz angegebener Bedingungen ausgeführt.

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

Parameter

continuationAction: Action<Task,Object>

state: Object

Ein Objekt, das Daten darstellt, die von der Fortsetzungsaktion verwendet werden sollen.

continuationOptions: TaskContinuationOptions

Optionen für die Planung und das Verhalten der Fortsetzung. Dazu zählen Kriterien wie OnlyOnCanceled und Ausführungsoptionen wie ExecuteSynchronously.

Gibt zurück

Task

Ein neuer Fortsetzungs-Task.

Ausnahmen

ArgumentNullException

Das continuationAction-Argument lautet null.

ArgumentOutOfRangeException

Das continuationOptions-Argument gibt einen ungültigen Wert für TaskContinuationOptions an.

Hinweise

Die zurückgegebene Task wird erst dann für die Ausführung geplant, wenn die aktuelle Aufgabe abgeschlossen ist. Wenn die durch den continuationOptions Parameter angegebenen Fortsetzungskriterien nicht erfüllt sind, wird der Fortsetzungstask abgebrochen und nicht geplant.

Gilt für:

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

Quelle:: Task.cs

Quelle:: Task.cs

Quelle:: Task.cs

Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen sowie ein Abbruchtoken empfängt und asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde.

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

Parameter

continuationAction: Action<Task,Object>

state: Object

Ein Objekt, das Daten darstellt, die von der Fortsetzungsaktion verwendet werden sollen.

cancellationToken: CancellationToken

Das CancellationToken, das der neuen Fortsetzungsaufgabe zugewiesen wird.

Gibt zurück

Task

Ein neuer Fortsetzungs-Task.

Ausnahmen

ArgumentNullException

Das continuationAction-Argument lautet null.

ObjectDisposedException

Das angegebene CancellationToken wurde bereits verworfen.

Hinweise

Gilt für:

ContinueWith(Action<Task>)

Quelle:: Task.cs

Quelle:: Task.cs

Quelle:: Task.cs

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde.

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

Parameter

continuationAction: Action<Task>

Eine Aktion, die beim Abschluss von Task ausgeführt werden soll. Bei der Ausführung wird dem Delegaten die abgeschlossene Aufgabe als Argument übergeben.

Gibt zurück

Task

Ein neuer Fortsetzungs-Task.

Ausnahmen

ArgumentNullException

Das continuationAction-Argument lautet null.

Beispiele

Im folgenden Beispiel wird eine Aufgabe definiert, die ein Array mit 100 zufälligen Datums- und Uhrzeitwerten auffüllt. Es verwendet die ContinueWith(Action<Task>) -Methode, um die frühesten und die neuesten Datumswerte auszuwählen, sobald das Array vollständig aufgefüllt ist.

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

Da eine Konsolenanwendung möglicherweise beendet wird, bevor der Fortsetzungstask ausgeführt wird, wird die Wait() -Methode aufgerufen, um sicherzustellen, dass die Fortsetzung ausgeführt wird, bevor das Beispiel endet.

Ein weiteres Beispiel finden Sie unter Verketten von Aufgaben mithilfe von Fortsetzungsaufgaben.

Hinweise

Gilt für:

ContinueWith(Action<Task>, TaskContinuationOptions)

Quelle:: Task.cs

Quelle:: Task.cs

Quelle:: Task.cs

Erstellt eine Fortsetzung, die, sobald die Zielaufgabe abgeschlossen ist, entsprechend den Angaben in TaskContinuationOptions ausgeführt wird.

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

Parameter

continuationAction: Action<Task>

Eine Aktion, die nach den angegebenen continuationOptions ausgeführt werden soll. Bei der Ausführung wird dem Delegaten die abgeschlossene Aufgabe als Argument übergeben.

continuationOptions: TaskContinuationOptions

Optionen für die Planung und das Verhalten der Fortsetzung. Dazu zählen Kriterien wie OnlyOnCanceled und Ausführungsoptionen wie ExecuteSynchronously.

Gibt zurück

Task

Ein neuer Fortsetzungs-Task.

Ausnahmen

ArgumentNullException

Das continuationAction-Argument ist null.

ArgumentOutOfRangeException

Das continuationOptions-Argument gibt einen ungültigen Wert für TaskContinuationOptions an.

Beispiele

Im folgenden Beispiel wird veranschaulicht, dass mithilfe von TaskContinuationOptions angegeben wird, dass ein Fortsetzungstask synchron ausgeführt werden soll, wenn der vorsehnte Task abgeschlossen ist. (Wenn der angegebene Task zum Zeitpunkt ContinueWith des Aufrufs bereits abgeschlossen ist, wird die synchrone Fortsetzung für den Thread ausgeführt, der aufruft 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

Hinweise

Gilt für:

ContinueWith(Action<Task>, CancellationToken)

Quelle:: Task.cs

Quelle:: Task.cs

Quelle:: Task.cs

Erstellt eine Fortsetzung, die ein Abbruchtoken empfängt und asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde.

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

Parameter

continuationAction: Action<Task>

Eine Aktion, die beim Abschluss von Task ausgeführt werden soll. Bei der Ausführung wird dem Delegaten die abgeschlossene Aufgabe als Argument übergeben.

cancellationToken: CancellationToken

Das CancellationToken, das der neuen Fortsetzungsaufgabe zugewiesen wird.

Gibt zurück

Task

Ein neuer Fortsetzungs-Task.

Ausnahmen

ObjectDisposedException

Die CancellationTokenSource, die das Token erstellt hat, wurde bereits freigegeben.

ArgumentNullException

Das continuationAction-Argument ist null.

Hinweise

Gilt für:

ContinueWith(Action<Task,Object>, Object)

Quelle:: Task.cs

Quelle:: Task.cs

Quelle:: Task.cs

Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen empfängt, und wird ausgeführt, wenn der Ziel-Task abgeschlossen ist.

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

Parameter

continuationAction: Action<Task,Object>

Eine Aktion, die ausgeführt werden soll, wenn die Aufgabe abgeschlossen wurde. Wenn der Delegat ausgeführt wird, werden ihm der abgeschlossene Task und das vom Aufrufer bereitgestellte Zustandsobjekt als Argumente übergeben.

state: Object

Ein Objekt, das Daten darstellt, die von der Fortsetzungsaktion verwendet werden sollen.

Gibt zurück

Task

Eine neue Fortsetzungsaufgabe.

Ausnahmen

ArgumentNullException

Das continuationAction-Argument lautet null.

Hinweise

Die zurückgegebene Task wird erst für die Ausführung geplant, wenn der aktuelle Task abgeschlossen ist, unabhängig davon, ob er aufgrund einer erfolgreichen Ausführung bis zum Abschluss, eines Fehlers aufgrund einer nicht behandelten Ausnahme oder eines vorzeitigen Beendens aufgrund eines Abbruchs abgeschlossen wird.

Gilt für:

ContinueWith(Action<Task>, TaskScheduler)

Quelle:: Task.cs

Quelle:: Task.cs

Quelle:: Task.cs

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde. Die Fortsetzung verwendet einen angegebenen Zeitplan.

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

Parameter

continuationAction: Action<Task>

Eine Aktion, die beim Abschluss von Task ausgeführt werden soll. Bei der Ausführung wird dem Delegaten die abgeschlossene Aufgabe als Argument übergeben.

scheduler: TaskScheduler

Das TaskScheduler, das der Fortsetzungsaufgabe zugeordnet und für ihre Ausführung verwendet werden soll.

Gibt zurück

Task

Ein neuer Fortsetzungs-Task.

Ausnahmen

ObjectDisposedException

Task wurde verworfen.

ArgumentNullException

Das continuationAction-Argument lautet null.

- oder -

Das scheduler-Argument ist null.

Hinweise

Gilt für:

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

Quelle:: Task.cs

Quelle:: Task.cs

Quelle:: Task.cs

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde. Die Fortsetzung empfängt vom Aufrufer bereitgestellte Zustandsinformationen und verwendet einen angegebenen Zeitplan.

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)

Typparameter

TResult

Der Typ des von der Fortsetzung generierten Ergebnisses.

Parameter

continuationFunction: Func<Task,Object,TResult>

Eine Funktion, die ausgeführt werden soll, wenn das Task abgeschlossen ist. Bei der Ausführung werden dem Delegaten die abgeschlossene Aufgabe und das vom Aufrufer angegebene Zustandsobjekt als Argumente übergeben.

state: Object

Ein Objekt, das Daten darstellt, die von der Fortsetzungsfunktion verwendet werden sollen.

scheduler: TaskScheduler

Das TaskScheduler, das der Fortsetzungsaufgabe zugeordnet und für ihre Ausführung verwendet werden soll.

Gibt zurück

Task<TResult>

Ein neuer Fortsetzungs-Task<TResult>.

Ausnahmen

ArgumentNullException

Das scheduler-Argument lautet null.

Hinweise

Die zurückgegebene Task<TResult> wird erst für die Ausführung geplant, wenn die aktuelle Aufgabe abgeschlossen ist, unabhängig davon, ob sie aufgrund einer erfolgreichen Ausführung bis zum Abschluss, eines Fehlers aufgrund einer nicht behandelten Ausnahme oder eines vorzeitigen Beendens aufgrund eines Abbruchs abgeschlossen wird.

Gilt für:

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

Quelle:: Task.cs

Quelle:: Task.cs

Quelle:: Task.cs

Erstellt eine Fortsetzung, die entsprechend den angegebenen Aufgabenfortsetzungsoptionen ausgeführt wird, wenn der Ziel-Task abgeschlossen ist, und gibt einen Wert zurück. Die Fortsetzung empfängt vom Aufrufer bereitgestellte Zustandsinformationen sowie ein Abbruchtoken und verwendet den angegebenen Zeitplan.

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)

Typparameter

TResult

Der Typ des von der Fortsetzung generierten Ergebnisses.

Parameter

continuationFunction: Func<Task,Object,TResult>

state: Object

Ein Objekt, das Daten darstellt, die von der Fortsetzungsfunktion verwendet werden sollen.

cancellationToken: CancellationToken

Das CancellationToken, das der neuen Fortsetzungsaufgabe zugewiesen wird.

continuationOptions: TaskContinuationOptions

Optionen für die Planung und das Verhalten der Fortsetzung. Dazu zählen Kriterien wie OnlyOnCanceled und Ausführungsoptionen wie ExecuteSynchronously.

scheduler: TaskScheduler

Das TaskScheduler, das der Fortsetzungsaufgabe zugeordnet und für ihre Ausführung verwendet werden soll.

Gibt zurück

Task<TResult>

Ein neuer Fortsetzungs-Task<TResult>.

Ausnahmen

ArgumentNullException

Das scheduler-Argument lautet null.

ArgumentOutOfRangeException

Das continuationOptions-Argument gibt einen ungültigen Wert für TaskContinuationOptions an.

ObjectDisposedException

Das angegebene CancellationToken wurde bereits verworfen.

Hinweise

Die zurückgegebene Task<TResult> wird erst dann für die Ausführung geplant, wenn die aktuelle Aufgabe abgeschlossen ist. Wenn die durch den continuationOptions Parameter angegebenen Kriterien nicht erfüllt werden, wird die Fortsetzungsaufgabe abgebrochen und nicht geplant.

Gilt für:

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

Quelle:: Task.cs

Quelle:: Task.cs

Quelle:: Task.cs

Erstellt eine Fortsetzung, die entsprechend den angegebenen Fortsetzungsoptionen ausgeführt wird, und gibt einen Wert zurück. An die Fortsetzung wird ein Abbruchtoken übergeben, und sie verwendet einen angegebenen Zeitplan.

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)

Typparameter

TResult

Der Typ des von der Fortsetzung generierten Ergebnisses.

Parameter

continuationFunction: Func<Task,TResult>

Eine Funktion, die gemäß dem angegebenen continuationOptions. Bei Ausführung ausgeführt werden soll, wird der Delegat die abgeschlossene Aufgabe als Argument übergeben.

cancellationToken: CancellationToken

Das CancellationToken, das der neuen Fortsetzungsaufgabe zugewiesen wird.

continuationOptions: TaskContinuationOptions

Optionen für die Planung und das Verhalten der Fortsetzung. Dazu zählen Kriterien wie OnlyOnCanceled und Ausführungsoptionen wie ExecuteSynchronously.

scheduler: TaskScheduler

Das TaskScheduler, das der Fortsetzungsaufgabe zugeordnet und für ihre Ausführung verwendet werden soll.

Gibt zurück

Task<TResult>

Ein neuer Fortsetzungs-Task<TResult>.

Ausnahmen

ObjectDisposedException

Task wurde verworfen.

- oder -

Die CancellationTokenSource, die das Token erstellt hat, wurde bereits freigegeben.

ArgumentNullException

Das continuationFunction-Argument ist null.

- oder -

Das scheduler-Argument ist null.

ArgumentOutOfRangeException

Das continuationOptions-Argument gibt einen ungültigen Wert für TaskContinuationOptions an.

Beispiele

Das folgende Beispiel zeigt, wie Die ContinueWith-Methode mit Fortsetzungsoptionen verwendet wird:

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

Hinweise

Gilt für:

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

Quelle:: Task.cs

Quelle:: Task.cs

Quelle:: Task.cs

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde, und gibt einen Wert zurück. Die Fortsetzung empfängt vom Aufrufer bereitgestellte Zustandsinformationen sowie ein Abbruchtoken.

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)

Typparameter

TResult

Der Typ des von der Fortsetzung generierten Ergebnisses.

Parameter

continuationFunction: Func<Task,Object,TResult>

state: Object

Ein Objekt, das Daten darstellt, die von der Fortsetzungsfunktion verwendet werden sollen.

cancellationToken: CancellationToken

Das CancellationToken, das der neuen Fortsetzungsaufgabe zugewiesen wird.

Gibt zurück

Task<TResult>

Ein neuer Fortsetzungs-Task<TResult>.

Ausnahmen

ArgumentNullException

Das continuationFunction-Argument lautet null.

ObjectDisposedException

Das angegebene CancellationToken wurde bereits verworfen.

Hinweise

Gilt für:

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

Quelle:: Task.cs

Quelle:: Task.cs

Quelle:: Task.cs

Erstellt eine Fortsetzung, die entsprechend den angegebenen Aufgabenfortsetzungsoptionen ausgeführt wird, wenn der Ziel-Task abgeschlossen ist. Die Fortsetzung empfängt vom Aufrufer bereitgestellte Zustandsinformationen.

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)

Typparameter

TResult

Der Typ des von der Fortsetzung generierten Ergebnisses.

Parameter

continuationFunction: Func<Task,Object,TResult>

state: Object

Ein Objekt, das Daten darstellt, die von der Fortsetzungsfunktion verwendet werden sollen.

continuationOptions: TaskContinuationOptions

Optionen für die Planung und das Verhalten der Fortsetzung. Dazu zählen Kriterien wie OnlyOnCanceled und Ausführungsoptionen wie ExecuteSynchronously.

Gibt zurück

Task<TResult>

Ein neuer Fortsetzungs-Task<TResult>.

Ausnahmen

ArgumentNullException

Das continuationFunction-Argument lautet null.

ArgumentOutOfRangeException

Das continuationOptions-Argument gibt einen ungültigen Wert für TaskContinuationOptions an.

Hinweise

Die zurückgegebene Task<TResult> wird erst dann für die Ausführung geplant, wenn die aktuelle Aufgabe abgeschlossen ist. Wenn die durch den continuationOptions Parameter angegebenen Fortsetzungskriterien nicht erfüllt sind, wird der Fortsetzungstask abgebrochen und nicht geplant.

Gilt für:

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

Quelle:: Task.cs

Quelle:: Task.cs

Quelle:: Task.cs

Erstellt eine Fortsetzung, die entsprechend den angegebenen Fortsetzungsoptionen ausgeführt wird, und gibt einen Wert zurück.

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)

Typparameter

TResult

Der Typ des von der Fortsetzung generierten Ergebnisses.

Parameter

continuationFunction: Func<Task,TResult>

Eine Funktion, die entsprechend der in continuationOptions angegebenen Bedingung ausgeführt wird. Bei der Ausführung wird dem Delegaten die abgeschlossene Aufgabe als Argument übergeben.

continuationOptions: TaskContinuationOptions

Optionen für die Planung und das Verhalten der Fortsetzung. Dazu zählen Kriterien wie OnlyOnCanceled und Ausführungsoptionen wie ExecuteSynchronously.

Gibt zurück

Task<TResult>

Ein neuer Fortsetzungs-Task<TResult>.

Ausnahmen

ObjectDisposedException

Task wurde verworfen.

ArgumentNullException

Das continuationFunction-Argument ist null.

ArgumentOutOfRangeException

Das continuationOptions-Argument gibt einen ungültigen Wert für TaskContinuationOptions an.

Hinweise

Die zurückgegebene Task<TResult> wird erst dann für die Ausführung geplant, wenn die aktuelle Aufgabe abgeschlossen ist. Wenn die durch den continuationOptions Parameter angegebenen Fortsetzungskriterien nicht erfüllt sind, wird der Fortsetzungstask abgebrochen und nicht geplant.

Gilt für:

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

Quelle:: Task.cs

Quelle:: Task.cs

Quelle:: Task.cs

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde, und gibt einen Wert zurück. Die Fortsetzung verwendet einen angegebenen Zeitplan.

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)

Typparameter

TResult

Der Typ des von der Fortsetzung generierten Ergebnisses.

Parameter

continuationFunction: Func<Task,TResult>

Eine Funktion, die ausgeführt werden soll, wenn das Task abgeschlossen ist. Bei der Ausführung wird dem Delegaten die abgeschlossene Aufgabe als Argument übergeben.

scheduler: TaskScheduler

Das TaskScheduler, das der Fortsetzungsaufgabe zugeordnet und für ihre Ausführung verwendet werden soll.

Gibt zurück

Task<TResult>

Ein neuer Fortsetzungs-Task<TResult>.

Ausnahmen

ObjectDisposedException

Task wurde verworfen.

ArgumentNullException

Das continuationFunction-Argument ist null.

- oder -

Das scheduler-Argument ist null.

Hinweise

Gilt für:

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

Quelle:: Task.cs

Quelle:: Task.cs

Quelle:: Task.cs

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde, und gibt einen Wert zurück. Die Fortsetzung empfängt ein Abbruchtoken.

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)

Typparameter

TResult

Der Typ des von der Fortsetzung generierten Ergebnisses.

Parameter

continuationFunction: Func<Task,TResult>

Eine Funktion, die ausgeführt werden soll, wenn das Task abgeschlossen ist. Bei der Ausführung wird dem Delegaten die abgeschlossene Aufgabe als Argument übergeben.

cancellationToken: CancellationToken

Das CancellationToken, das der neuen Fortsetzungsaufgabe zugewiesen wird.

Gibt zurück

Task<TResult>

Ein neuer Fortsetzungs-Task<TResult>.

Ausnahmen

ObjectDisposedException

Task wurde verworfen.

- oder -

Die CancellationTokenSource, die das Token erstellt hat, wurde bereits freigegeben.

ArgumentNullException

Das continuationFunction-Argument ist null.

Hinweise

Gilt für:

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

Quelle:: Task.cs

Quelle:: Task.cs

Quelle:: Task.cs

Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen empfängt, und wird asynchron ausgeführt, wenn der Ziel-Task abgeschlossen ist, und gibt einen Wert zurück.

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)

Typparameter

TResult

Der Typ des von der Fortsetzung generierten Ergebnisses.

Parameter

continuationFunction: Func<Task,Object,TResult>

state: Object

Ein Objekt, das Daten darstellt, die von der Fortsetzungsfunktion verwendet werden sollen.

Gibt zurück

Task<TResult>

Ein neuer Fortsetzungs-Task<TResult>.

Ausnahmen

ArgumentNullException

Das continuationFunction-Argument lautet null.

Hinweise

Gilt für:

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

Quelle:: Task.cs

Quelle:: Task.cs

Quelle:: Task.cs

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task<TResult> abgeschlossen wurde, und gibt einen Wert zurück.

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)

Typparameter

TResult

Der Typ des von der Fortsetzung generierten Ergebnisses.

Parameter

continuationFunction: Func<Task,TResult>

Eine Funktion, die ausgeführt werden soll, wenn das Task<TResult> abgeschlossen ist. Bei der Ausführung wird dem Delegaten die abgeschlossene Aufgabe als Argument übergeben.

Gibt zurück

Task<TResult>

Eine neue Fortsetzungsaufgabe.

Ausnahmen

ObjectDisposedException

Task wurde verworfen.

ArgumentNullException

Das continuationFunction-Argument ist null.

Beispiele

Das folgende Beispiel zeigt die Verwendung der ContinueWith-Methode:

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

Hinweise

Gilt für:

Freigeben über

Task.ContinueWith Methode

Definition

Überlädt

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

Parameter

Gibt zurück

Ausnahmen

Hinweise

Gilt für:

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

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Gilt für:

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

Parameter

Gibt zurück

Ausnahmen

Hinweise

Gilt für:

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

Parameter

Gibt zurück

Ausnahmen

Hinweise

Gilt für:

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

Parameter

Gibt zurück

Ausnahmen

Hinweise

Gilt für:

ContinueWith(Action<Task>)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Gilt für:

ContinueWith(Action<Task>, TaskContinuationOptions)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Gilt für:

ContinueWith(Action<Task>, CancellationToken)

Parameter

Gibt zurück

Ausnahmen

Hinweise

Gilt für:

ContinueWith(Action<Task,Object>, Object)

Parameter

Gibt zurück

Ausnahmen

Hinweise

Gilt für:

ContinueWith(Action<Task>, TaskScheduler)

Parameter

Gibt zurück

Ausnahmen

Hinweise

Gilt für:

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

Typparameter

Parameter

Gibt zurück

Ausnahmen

Hinweise

Gilt für:

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

Typparameter

Parameter

Gibt zurück

Ausnahmen

Hinweise