Task<TResult>.ContinueWith Methode

Definition

Erstellt eine Fortsetzungsaufgabe, die ausgeführt wird, wenn eine andere Aufgabe beendet ist.

Überlädt

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

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.

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

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.

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

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.

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

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.

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

Erstellt eine Fortsetzung, die nach der in continuationOptions angegebenen Bedingung ausgeführt wird.

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

Erstellt eine Fortsetzung, die nach der in continuationOptions angegebenen Bedingung ausgeführt wird.

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

Erstellt eine abzubrechende Fortsetzung, die asynchron ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen wurde.

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

Erstellt eine Fortsetzung, an die Zustandsinformationen übergeben werden und die ausgeführt wird, wenn der Ziel-Task<TResult> abgeschlossen ist.

ContinueWith(Action<Task<TResult>>)

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn die Zielaufgabe abgeschlossen wurde.

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

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

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

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.

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

Erstellt eine Fortsetzung, die nach der in continuationOptions angegebenen Bedingung ausgeführt wird.

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

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.

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

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.

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

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.

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

Erstellt eine Fortsetzung, die nach der in continuationOptions angegebenen Bedingung ausgeführt wird.

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

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

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

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.

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

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

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

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

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

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.

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

Parameter

continuationAction
Action<Task<TResult>,Object>

Eine Aktion, die beim Abschluss von Task<TResult> 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

Das scheduler-Argument lautet null.

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

Das angegebene CancellationToken wurde bereits verworfen.

Hinweise

Die zurückgegebene Task Aufgabe wird erst für die Ausführung geplant, wenn der aktuelle Vorgang abgeschlossen wurde. Wenn die durch den continuationOptions Parameter angegebenen Kriterien nicht erfüllt sind, wird der Fortsetzungsvorgang statt geplant abgebrochen.

Siehe auch

Gilt für:

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

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.

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

Parameter

continuationAction
Action<Task<TResult>,Object>

Eine Aktion, die beim Abschluss von Task<TResult> 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.

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

Das scheduler-Argument lautet null.

Hinweise

Die zurückgegebene Task Aufgabe wird erst für die Ausführung geplant, wenn der aktuelle Vorgang abgeschlossen ist, unabhängig davon, ob die Ausführung erfolgreich abgeschlossen ist, aufgrund einer nicht behandelten Ausnahme fehlerhafter Fehler oder vorzeitiges Beenden aufgrund eines Abbruchs.

Siehe auch

Gilt für:

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

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.

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

Parameter

continuationAction
Action<Task<TResult>,Object>

Eine Aktion, die beim Abschluss von Task<TResult> 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.

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

Das continuationAction-Argument lautet null.

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

Hinweise

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

Siehe auch

Gilt für:

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

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.

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

Parameter

continuationAction
Action<Task<TResult>,Object>

Eine Aktion, die beim Abschluss von Task<TResult> 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.

Gibt zurück

Task

Ein neuer Fortsetzungs-Task.

Ausnahmen

Das continuationAction-Argument lautet null.

Das angegebene CancellationToken wurde bereits verworfen.

Hinweise

Die zurückgegebene Task Aufgabe wird erst für die Ausführung geplant, wenn der aktuelle Vorgang abgeschlossen ist, unabhängig davon, ob die Ausführung erfolgreich abgeschlossen ist, aufgrund einer nicht behandelten Ausnahme fehlerhafter Fehler oder vorzeitiges Beenden aufgrund eines Abbruchs.

Siehe auch

Gilt für:

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

Erstellt eine Fortsetzung, die nach der in continuationOptions angegebenen Bedingung ausgeführt wird.

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

Parameter

continuationAction
Action<Task<TResult>>

Eine Aktion, die entsprechend der in continuationOptions angegebenen Bedingung ausgeführt wird. 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

Task<TResult> wurde verworfen.

- oder - Die CancellationTokenSource, die cancellationToken erstellt hat, wurde bereits freigegeben.

Das continuationAction-Argument lautet null.

- oder - Das scheduler-Argument lautet null.

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

Hinweise

Die zurückgegebene Task Aufgabe wird erst für die Ausführung geplant, wenn der aktuelle Vorgang abgeschlossen wurde. Wenn die durch den continuationOptions Parameter angegebenen Kriterien nicht erfüllt sind, wird der Fortsetzungsvorgang statt geplant abgebrochen. Weitere Informationen finden Sie unter Verketten von Aufgaben mithilfe von Fortsetzungsaufgaben.

Siehe auch

Gilt für:

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

Erstellt eine Fortsetzung, die nach der in continuationOptions angegebenen Bedingung ausgeführt wird.

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

Parameter

continuationAction
Action<Task<TResult>>

Eine Aktion, 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

Ein neuer Fortsetzungs-Task.

Ausnahmen

Das continuationAction-Argument lautet null.

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

Hinweise

Die zurückgegebene Task Ausführung wird erst geplant, wenn der aktuelle Vorgang abgeschlossen ist. Wenn die durch den continuationOptions Parameter angegebenen Fortsetzungskriterien nicht erfüllt sind, wird die Fortsetzungsaufgabe statt geplant abgebrochen.

Weitere Informationen finden Sie unter Verketten von Aufgaben mithilfe von Fortsetzungsaufgaben.

Siehe auch

Gilt für:

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

Erstellt eine abzubrechende Fortsetzung, die asynchron ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen wurde.

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

Parameter

continuationAction
Action<Task<TResult>>

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

cancellationToken
CancellationToken

Das Abbruchtoken, das an die neue Fortsetzungsaufgabe übergeben werden soll.

Gibt zurück

Task

Eine neue Fortsetzungsaufgabe.

Ausnahmen

Task<TResult> wurde verworfen.

- oder - Die CancellationTokenSource, die cancellationToken erstellt hat, wurde gelöscht.

Das continuationAction-Argument lautet null.

Beispiele

Im folgenden Beispiel wird eine antecedent-Aufgabe erstellt, die die Sieve von Eratosthenes verwendet, um die Primzahlen zwischen 1 und einem vom Benutzer eingegebenen Wert zu berechnen. Ein Array wird verwendet, um Informationen zu den Primzahlen zu halten. Der Arrayindex stellt die Zahl dar, und der Wert des Elements gibt an, ob diese Zahl zusammengesetzt ist (der Wert ist true) oder prime (der Wert ist false). Diese Aufgabe wird dann an eine Fortsetzungsaufgabe übergeben, die für das Extrahieren der Primzahlen aus dem ganzzahligen Array verantwortlich ist und sie anzeigt.

Ein Abbruchtoken wird sowohl an die antecedent als auch an die Fortsetzungsaufgabe übergeben. Ein System.Timers.Timer Objekt wird verwendet, um einen Timeoutwert von 100 Millisekunden zu definieren. Wenn das Ereignis ausgelöst wird, wird die Methode aufgerufen, und das CancellationTokenSource.Cancel Abbruchtoken wird verwendet, um die Abbruch der Vorgänge anzufordern.

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

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

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

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

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

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

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

Module Example
   Dim ts As CancellationTokenSource

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

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

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

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

In der Regel führt die Bereitstellung eines Werts von etwa 100.000 dazu, dass das Timeoutintervall abläuft und das Ereignis ausgelöst wird, und die Timer.Elapsed Abbruchanforderung, die festgelegt werden soll.

Hinweise

Die zurückgegebene Task Ausführung wird erst geplant, wenn der aktuelle Vorgang abgeschlossen wurde, ob er aufgrund einer erfolgreichen Ausführung abgeschlossen wird, aufgrund einer nicht behandelten Ausnahme oder aufgrund einer nicht behandelten Ausnahme oder aufgrund eines frühen Abbruchs abzubrechen.

Siehe auch

Gilt für:

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

Erstellt eine Fortsetzung, an die Zustandsinformationen übergeben werden und die ausgeführt wird, wenn der Ziel-Task<TResult> abgeschlossen ist.

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

Parameter

continuationAction
Action<Task<TResult>,Object>

Eine Aktion, die beim Abschluss von Task<TResult> ausgeführt werden soll. 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

Ein neuer Fortsetzungs-Task.

Ausnahmen

Das continuationAction-Argument lautet null.

Beispiele

Im folgenden Beispiel wird eine Aufgabe erstellt, die eine ganze Zahl zwischen 2 und 20 übergeben und ein Array zurückgibt, das die ersten zehn Exponenten (von n1 bis n10) dieser Zahl enthält. Eine Fortsetzungsaufgabe ist dann für die Anzeige der Exponenten verantwortlich. Es wird sowohl die Antecedent als auch die ursprüngliche Zahl übergeben, deren Exponent die Antecedent generiert.

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

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

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

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

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

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

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

Hinweise

Die zurückgegebene Task Ausführung wird erst geplant, wenn der aktuelle Vorgang abgeschlossen wurde, ob er aufgrund einer erfolgreichen Ausführung abgeschlossen wird, aufgrund einer nicht behandelten Ausnahme oder aufgrund einer nicht behandelten Ausnahme oder aufgrund eines frühen Abbruchs abzubrechen.

Siehe auch

Gilt für:

ContinueWith(Action<Task<TResult>>)

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn die Zielaufgabe abgeschlossen wurde.

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

Parameter

continuationAction
Action<Task<TResult>>

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

Gibt zurück

Task

Eine neue Fortsetzungsaufgabe.

Ausnahmen

Das continuationAction-Argument lautet null.

Beispiele

Im folgenden Beispiel wird eine antecedent-Aufgabe erstellt, die die Sieve von Eratosthenes verwendet, um die Primzahlen zwischen 1 und einem vom Benutzer eingegebenen Wert zu berechnen. Ein Array wird verwendet, um Informationen zu den Primzahlen zu halten. Der Arrayindex stellt die Zahl dar, und der Wert des Elements gibt an, ob diese Zahl zusammengesetzt ist (der Wert ist true) oder prime (der Wert ist false). Diese Aufgabe wird dann an eine Fortsetzungsaufgabe übergeben, die für das Extrahieren der Primzahlen aus dem ganzzahligen Array verantwortlich ist und sie anzeigt.

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

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

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

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

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

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

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

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

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

Hinweise

Die zurückgegebene Task Ausführung wird erst geplant, wenn der aktuelle Vorgang abgeschlossen ist, ob es aufgrund der erfolgreichen Ausführung abgeschlossen ist, aufgrund einer nicht behandelten Ausnahme oder aufgrund einer nicht behandelten Ausnahme oder aufgrund des Abbruchs frühzeitig beendet wird.

Siehe auch

Gilt für:

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

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

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

Parameter

continuationAction
Action<Task<TResult>>

Eine Aktion, die beim Abschluss von Task<TResult> 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

Das continuationAction-Argument lautet null.

- oder - Das scheduler-Argument lautet null.

Hinweise

Die zurückgegebene Task Aufgabe wird erst für die Ausführung geplant, wenn der aktuelle Vorgang abgeschlossen ist, unabhängig davon, ob die Ausführung erfolgreich abgeschlossen ist, aufgrund einer nicht behandelten Ausnahme fehlerhafter Fehler oder vorzeitiges Beenden aufgrund eines Abbruchs.

Siehe auch

Gilt für:

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

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.

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

Typparameter

TNewResult

Der Typ des von der Fortsetzung generierten Ergebnisses.

Parameter

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

Eine Funktion, die ausgeführt werden soll, wenn das Task<TResult> 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.

cancellationToken
CancellationToken

Das CancellationToken, das der neuen Aufgabe 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<TNewResult>

Ein neuer Fortsetzungs-Task<TResult>.

Ausnahmen

Das scheduler-Argument lautet null.

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

Das angegebene CancellationToken wurde bereits verworfen.

Hinweise

Die zurückgegebene Task<TResult> Aufgabe wird erst für die Ausführung geplant, wenn der aktuelle Vorgang abgeschlossen ist, unabhängig davon, ob die Ausführung erfolgreich abgeschlossen ist, aufgrund einer nicht behandelten Ausnahme fehlerhafter Fehler oder vorzeitiges Beenden aufgrund eines Abbruchs.

Die continuationFunction, wenn ausgeführt, sollte eine Task<TResult>. Der Abschlussstatus dieser Aufgabe wird an den vom Aufruf zurückgegebenen Task<TResult>.ContinueWith Vorgang übertragen.

Siehe auch

Gilt für:

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

Erstellt eine Fortsetzung, die nach der in continuationOptions angegebenen Bedingung ausgeführt wird.

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

Typparameter

TNewResult

Der Typ des von der Fortsetzung generierten Ergebnisses.

Parameter

continuationFunction
Func<Task<TResult>,TNewResult>

Eine Funktion, die entsprechend der in continuationOptions angegebenen Bedingung ausgeführt wird.

Bei der Ausführung wird dem Delegaten diese abgeschlossene Aufgabe als Argument übergeben.

cancellationToken
CancellationToken

Das CancellationToken, das der neuen Aufgabe 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<TNewResult>

Ein neuer Fortsetzungs-Task<TResult>.

Ausnahmen

Task<TResult> wurde verworfen.

- oder - Die CancellationTokenSource, die cancellationToken erstellt hat, wurde bereits freigegeben.

Das continuationFunction-Argument lautet null.

- oder - Das scheduler-Argument lautet null.

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

Hinweise

Die zurückgegebene Task<TResult> Ausführung wird erst geplant, wenn der aktuelle Vorgang abgeschlossen wurde, ob er aufgrund einer erfolgreichen Ausführung abgeschlossen wird, aufgrund einer nicht behandelten Ausnahme oder aufgrund einer nicht behandelten Ausnahme oder aufgrund eines frühen Abbruchs abzubrechen.

Die continuationFunctionbeim Ausführen ausgeführte Datei sollte einen Task<TResult>Wert zurückgeben.

Siehe auch

Gilt für:

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

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.

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

Typparameter

TNewResult

Der Typ des von der Fortsetzung generierten Ergebnisses.

Parameter

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

Eine Funktion, die ausgeführt werden soll, wenn das Task<TResult> 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<TNewResult>

Ein neuer Fortsetzungs-Task<TResult>.

Ausnahmen

Das scheduler-Argument lautet null.

Hinweise

Die zurückgegebene Task<TResult> Ausführung wird erst geplant, wenn der aktuelle Vorgang abgeschlossen wurde, ob er aufgrund einer erfolgreichen Ausführung abgeschlossen wird, aufgrund einer nicht behandelten Ausnahme oder aufgrund einer nicht behandelten Ausnahme oder aufgrund eines frühen Abbruchs abzubrechen.

Siehe auch

Gilt für:

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

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.

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

Typparameter

TNewResult

Der Typ des von der Fortsetzung generierten Ergebnisses.

Parameter

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

Eine Funktion, die ausgeführt werden soll, wenn das Task<TResult> 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.

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

Ein neuer Fortsetzungs-Task<TResult>.

Ausnahmen

Das continuationFunction-Argument lautet null.

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

Hinweise

Die zurückgegebene Task<TResult> Ausführung wird erst geplant, wenn der aktuelle Vorgang abgeschlossen wurde, ob er aufgrund einer erfolgreichen Ausführung abgeschlossen wird, aufgrund einer nicht behandelten Ausnahme oder aufgrund einer nicht behandelten Ausnahme oder aufgrund eines frühen Abbruchs abzubrechen.

Die continuationFunctionbeim Ausführen ausgeführte Datei sollte einen Task<TResult>Wert zurückgeben. Der Abschlusszustand dieser Aufgabe wird an den vom ContinueWith-Aufruf zurückgegebenen Vorgang übertragen.

Siehe auch

Gilt für:

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

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.

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

Typparameter

TNewResult

Der Typ des von der Fortsetzung generierten Ergebnisses.

Parameter

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

Eine Funktion, die ausgeführt werden soll, wenn das Task<TResult> 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.

cancellationToken
CancellationToken

Das CancellationToken, das der neuen Aufgabe zugewiesen wird.

Gibt zurück

Task<TNewResult>

Ein neuer Fortsetzungs-Task<TResult>.

Ausnahmen

Das continuationFunction-Argument lautet null.

Das angegebene CancellationToken wurde bereits verworfen.

Hinweise

Die zurückgegebene Task<TResult> Ausführung wird erst geplant, wenn der aktuelle Vorgang abgeschlossen wurde, ob er aufgrund einer erfolgreichen Ausführung abgeschlossen wird, aufgrund einer nicht behandelten Ausnahme oder aufgrund einer nicht behandelten Ausnahme oder aufgrund eines frühen Abbruchs abzubrechen.

Siehe auch

Gilt für:

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

Erstellt eine Fortsetzung, die nach der in continuationOptions angegebenen Bedingung ausgeführt wird.

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

Typparameter

TNewResult

Der Typ des von der Fortsetzung generierten Ergebnisses.

Parameter

continuationFunction
Func<Task<TResult>,TNewResult>

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

Ein neuer Fortsetzungs-Task<TResult>.

Ausnahmen

Das continuationFunction-Argument lautet null.

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

Hinweise

Die zurückgegebene Task<TResult> Ausführung wird erst geplant, wenn der aktuelle Vorgang abgeschlossen wurde, ob er aufgrund einer erfolgreichen Ausführung abgeschlossen wird, aufgrund einer nicht behandelten Ausnahme oder aufgrund einer nicht behandelten Ausnahme oder aufgrund eines frühen Abbruchs abzubrechen.

Die continuationFunctionbeim Ausführen ausgeführte Datei sollte einen Task<TResult>Wert zurückgeben.

Siehe auch

Gilt für:

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

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

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

Typparameter

TNewResult

Der Typ des von der Fortsetzung generierten Ergebnisses.

Parameter

continuationFunction
Func<Task<TResult>,TNewResult>

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.

cancellationToken
CancellationToken

Das CancellationToken, das der neuen Aufgabe zugewiesen wird.

Gibt zurück

Task<TNewResult>

Ein neuer Fortsetzungs-Task<TResult>.

Ausnahmen

Task<TResult> wurde verworfen.

- oder - Die CancellationTokenSource, die cancellationToken erstellt hat, wurde bereits freigegeben.

Das continuationFunction-Argument lautet null.

Hinweise

Die zurückgegebene Task<TResult> Ausführung wird erst geplant, wenn der aktuelle Vorgang abgeschlossen wurde, ob er aufgrund einer erfolgreichen Ausführung abgeschlossen wird, aufgrund einer nicht behandelten Ausnahme oder aufgrund einer nicht behandelten Ausnahme oder aufgrund eines frühen Abbruchs abzubrechen.

Siehe auch

Gilt für:

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

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.

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

Typparameter

TNewResult

Der Typ des von der Fortsetzung generierten Ergebnisses.

Parameter

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

Eine Funktion, die ausgeführt werden soll, wenn das Task<TResult> 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.

Gibt zurück

Task<TNewResult>

Ein neuer Fortsetzungs-Task<TResult>.

Ausnahmen

Das continuationFunction-Argument lautet null.

Beispiele

Im folgenden Beispiel wird eine Kette von Fortsetzungsaufgaben erstellt. Jede Aufgabe stellt die aktuelle Uhrzeit, ein DateTime Objekt, für das Statusargument der ContinueWith(Action<Task,Object>, Object) Methode bereit. Jeder DateTime Wert stellt die Uhrzeit dar, zu der die Fortsetzungsaufgabe erstellt wird. Jede Aufgabe erzeugt als Ergebnis einen zweiten DateTime Wert, der die Zeit darstellt, zu der die Aufgabe beendet wird. Nach Abschluss aller Vorgänge zeigt das Beispiel das Datum und die Uhrzeit an, zu der jede Fortsetzungsaufgabe beginnt und beendet.

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

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

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

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

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

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

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

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

/* Sample output:
Task was created at 10:56:21.1561762 and finished at 10:56:25.1672062.
Task was created at 10:56:21.1610677 and finished at 10:56:27.1707646.
Task was created at 10:56:21.1610677 and finished at 10:56:29.1743230.
Task was created at 10:56:21.1610677 and finished at 10:56:31.1779883.
Task was created at 10:56:21.1610677 and finished at 10:56:33.1837083.
*/
Imports System.Collections.Generic
Imports System.Threading
Imports System.Threading.Tasks

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

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

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

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

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

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

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

Hinweise

Die zurückgegebene Task<TResult> Aufgabe wird erst für die Ausführung geplant, wenn der aktuelle Vorgang abgeschlossen ist, unabhängig davon, ob die Ausführung erfolgreich abgeschlossen ist, aufgrund einer nicht behandelten Ausnahme fehlerhafter Fehler oder vorzeitiges Beenden aufgrund eines Abbruchs.

Siehe auch

Gilt für:

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

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

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

Typparameter

TNewResult

Der Typ des von der Fortsetzung generierten Ergebnisses.

Parameter

continuationFunction
Func<Task<TResult>,TNewResult>

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

Ein neuer Fortsetzungs-Task<TResult>.

Ausnahmen

Das continuationFunction-Argument lautet null.

Hinweise

Die zurückgegebene Task<TResult> Aufgabe wird erst für die Ausführung geplant, wenn der aktuelle Vorgang abgeschlossen ist, unabhängig davon, ob die Ausführung erfolgreich abgeschlossen ist, aufgrund einer nicht behandelten Ausnahme fehlerhafter Fehler oder vorzeitiges Beenden aufgrund eines Abbruchs.

Siehe auch

Gilt für:

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

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

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

Typparameter

TNewResult

Der Typ des von der Fortsetzung generierten Ergebnisses.

Parameter

continuationFunction
Func<Task<TResult>,TNewResult>

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.

scheduler
TaskScheduler

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

Gibt zurück

Task<TNewResult>

Ein neuer Fortsetzungs-Task<TResult>.

Ausnahmen

Das continuationFunction-Argument lautet null.

- oder - Das scheduler-Argument lautet null.

Hinweise

Die zurückgegebene Task<TResult> Ausführung wird erst geplant, wenn der aktuelle Vorgang abgeschlossen wurde, ob er aufgrund einer erfolgreichen Ausführung abgeschlossen wird, aufgrund einer nicht behandelten Ausnahme oder aufgrund einer nicht behandelten Ausnahme oder aufgrund eines frühen Abbruchs abzubrechen.

Siehe auch

Gilt für: