Task<TResult>.ContinueWith Methode

Definition

Namespace:

System.Threading.Tasks

Assembly:

System.Runtime.dll

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, CancellationToken)	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>,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)

Quelle:

Future.cs

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>,object?> continuationAction, object? state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);

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

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 die aktuelle Aufgabe abgeschlossen ist. Wenn die durch den continuationOptions Parameter angegebenen Kriterien nicht erfüllt werden, wird die Fortsetzungsaufgabe abgebrochen und nicht geplant.

Weitere Informationen

• Verketten von Aufgaben mithilfe von Fortsetzungsaufgaben

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

Quelle:

Future.cs

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>,object?> continuationAction, object? state, System.Threading.Tasks.TaskScheduler scheduler);

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

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.

Weitere Informationen

• Verketten von Aufgaben mithilfe von Fortsetzungsaufgaben

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

Quelle:

Future.cs

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>,object?> continuationAction, object? state, System.Threading.Tasks.TaskContinuationOptions continuationOptions);

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

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.

Weitere Informationen

• Verketten von Aufgaben mithilfe von Fortsetzungsaufgaben

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

Quelle:

Future.cs

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>,object?> continuationAction, object? state, System.Threading.CancellationToken cancellationToken);

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

ArgumentNullException

Das continuationAction-Argument lautet null.

ObjectDisposedException

Das angegebene CancellationToken wurde bereits verworfen.

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.

Weitere Informationen

• Verketten von Aufgaben mithilfe von Fortsetzungsaufgaben

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

Quelle:

Future.cs

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);

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

ObjectDisposedException

Task<TResult> wurde verworfen.

- oder -

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

ArgumentNullException

Das continuationAction-Argument lautet null.

- oder -

Das scheduler-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 Kriterien nicht erfüllt werden, wird die Fortsetzungsaufgabe abgebrochen und nicht geplant. Weitere Informationen finden Sie unter Verketten von Aufgaben mithilfe von Fortsetzungsaufgaben.

Weitere Informationen

• Task Parallel Library (TPL)
• Aufgabenbasierte asynchrone Programmierung
• Verketten von Aufgaben mithilfe von Fortsetzungsaufgaben

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

Quelle:

Future.cs

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);

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

ObjectDisposedException

Task<TResult> wurde verworfen.

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.

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

Weitere Informationen

• Task Parallel Library (TPL)
• Aufgabenbasierte asynchrone Programmierung
• Verketten von Aufgaben mithilfe von Fortsetzungsaufgaben

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

Quelle:

Future.cs

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);

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

ObjectDisposedException

Task<TResult> wurde verworfen.

- oder -

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

ArgumentNullException

Das continuationAction-Argument lautet null.

Beispiele

Im folgenden Beispiel wird eine vorgegangene Aufgabe erstellt, die das 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 enthalten. Der Arrayindex stellt die Zahl dar, und der Wert des Elements gibt an, ob diese Zahl zusammengesetzt ist (ihr Wert ist true) oder prime (ihr Wert ist false). Diese Aufgabe wird dann an eine Fortsetzungsaufgabe übergeben, die für das Extrahieren der Primzahlen aus dem Ganzzahlarray und deren Anzeige zuständig ist.

Ein Abbruchtoken wird sowohl an den Vor- als auch an den Fortsetzungstask übergeben. Ein System.Timers.Timer -Objekt wird verwendet, um einen Timeoutwert von 100 Millisekunden zu definieren. Wenn das Ereignis ausgelöst wird, wird die CancellationTokenSource.Cancel -Methode aufgerufen, und das Abbruchtoken wird verwendet, um den Abbruch der Aufgaben 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.

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

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.

Weitere Informationen

• Task Parallel Library (TPL)
• Aufgabenbasierte asynchrone Programmierung
• Verketten von Aufgaben mithilfe von Fortsetzungsaufgaben

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

Quelle:

Future.cs

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>,object?> continuationAction, object? state);

Parameter

continuationAction

Action<Task<TResult>,Object>

Eine Aktion, die beim Abschluss von Task<TResult> ausgeführt werden soll. Bei der Ausführung wird der Delegat die abgeschlossene Aufgabe 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

ArgumentNullException

Das continuationAction-Argument lautet null.

Beispiele

Im folgenden Beispiel wird eine Aufgabe erstellt, die eine ganze Zahl zwischen 2 und 20 übergeben wird, und gibt ein Array zurück, das die ersten zehn Exponenten (von n¹ bis n¹⁰) dieser Zahl enthält. Eine Fortsetzungsaufgabe ist dann für die Anzeige der Exponenten verantwortlich. Es wird sowohl der Vor- als auch die ursprüngliche Zahl übergeben, deren Exponenten der Antecedens 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

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.

Weitere Informationen

• Verketten von Aufgaben mithilfe von Fortsetzungsaufgaben

ContinueWith(Action<Task<TResult>>)

Quelle:

Future.cs

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);

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

ObjectDisposedException

Task<TResult> wurde verworfen.

ArgumentNullException

Das continuationAction-Argument lautet null.

Beispiele

Im folgenden Beispiel wird eine vorgegangene Aufgabe erstellt, die das 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 enthalten. Der Arrayindex stellt die Zahl dar, und der Wert des Elements gibt an, ob diese Zahl zusammengesetzt ist (ihr Wert ist true) oder prime (ihr Wert ist false). Diese Aufgabe wird dann an eine Fortsetzungsaufgabe übergeben, die für das Extrahieren der Primzahlen aus dem Ganzzahlarray und deren Anzeige zuständig ist.

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

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 abgeschlossen wird, ein Fehler aufgrund einer nicht behandelten Ausnahme auftritt oder vorzeitig beendet wird, weil sie abgebrochen wurde.

Weitere Informationen

• Task Parallel Library (TPL)
• Aufgabenbasierte asynchrone Programmierung
• Verketten von Aufgaben mithilfe von Fortsetzungsaufgaben

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

Quelle:

Future.cs

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);

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

ObjectDisposedException

Task<TResult> wurde verworfen.

ArgumentNullException

Das continuationAction-Argument lautet null.

- oder -

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.

Weitere Informationen

• Task Parallel Library (TPL)
• Aufgabenbasierte asynchrone Programmierung
• Verketten von Aufgaben mithilfe von Fortsetzungsaufgaben

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

Quelle:

Future.cs

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

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);

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

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

Wenn continuationFunctionausgeführt wird, sollte ein Task<TResult>zurückgegeben werden. Der Abschlusszustand dieser Aufgabe wird an die aufgabe übertragen, die Task<TResult>.ContinueWith vom Aufruf zurückgegeben wird.

Weitere Informationen

• Verketten von Aufgaben mithilfe von Fortsetzungsaufgaben

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

Quelle:

Future.cs

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

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);

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

ObjectDisposedException

Task<TResult> wurde verworfen.

- oder -

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

ArgumentNullException

Das continuationFunction-Argument lautet null.

- oder -

Das scheduler-Argument lautet null.

ArgumentOutOfRangeException

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

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.

Der continuationFunctionsollte bei Ausführung einen Task<TResult>zurückgeben.

Weitere Informationen

• Task Parallel Library (TPL)
• Aufgabenbasierte asynchrone Programmierung
• Verketten von Aufgaben mithilfe von Fortsetzungsaufgaben

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

Quelle:

Future.cs

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

public System.Threading.Tasks.Task<TNewResult> ContinueWith<TNewResult> (Func<System.Threading.Tasks.Task<TResult>,object?,TNewResult> continuationFunction, object? state, System.Threading.Tasks.TaskScheduler scheduler);

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

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.

Weitere Informationen

• Verketten von Aufgaben mithilfe von Fortsetzungsaufgaben

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

Quelle:

Future.cs

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

public System.Threading.Tasks.Task<TNewResult> ContinueWith<TNewResult> (Func<System.Threading.Tasks.Task<TResult>,object?,TNewResult> continuationFunction, object? state, System.Threading.CancellationToken cancellationToken);

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

ArgumentNullException

Das continuationFunction-Argument lautet null.

ObjectDisposedException

Das angegebene CancellationToken wurde bereits verworfen.

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.

Weitere Informationen

• Verketten von Aufgaben mithilfe von Fortsetzungsaufgaben

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

Quelle:

Future.cs

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

public System.Threading.Tasks.Task<TNewResult> ContinueWith<TNewResult> (Func<System.Threading.Tasks.Task<TResult>,object?,TNewResult> continuationFunction, object? state, System.Threading.Tasks.TaskContinuationOptions continuationOptions);

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

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

Der continuationFunctionsollte bei Ausführung einen Task<TResult>zurückgeben. Der Abschlusszustand dieser Aufgabe wird auf den Vorgang übertragen, der vom ContinueWith-Aufruf zurückgegeben wird.

Weitere Informationen

• Verketten von Aufgaben mithilfe von Fortsetzungsaufgaben

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

Quelle:

Future.cs

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

public System.Threading.Tasks.Task<TNewResult> ContinueWith<TNewResult> (Func<System.Threading.Tasks.Task<TResult>,TNewResult> continuationFunction, System.Threading.Tasks.TaskContinuationOptions continuationOptions);

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

ObjectDisposedException

Task<TResult> wurde verworfen.

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

Der continuationFunctionsollte bei Ausführung einen Task<TResult>zurückgeben.

Weitere Informationen

• Task Parallel Library (TPL)
• Aufgabenbasierte asynchrone Programmierung
• Verketten von Aufgaben mithilfe von Fortsetzungsaufgaben

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

Quelle:

Future.cs

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

public System.Threading.Tasks.Task<TNewResult> ContinueWith<TNewResult> (Func<System.Threading.Tasks.Task<TResult>,TNewResult> continuationFunction, System.Threading.CancellationToken cancellationToken);

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

ObjectDisposedException

Task<TResult> wurde verworfen.

- oder -

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

ArgumentNullException

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

Weitere Informationen

• Task Parallel Library (TPL)
• Aufgabenbasierte asynchrone Programmierung
• Verketten von Aufgaben mithilfe von Fortsetzungsaufgaben

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

Quelle:

Future.cs

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

public System.Threading.Tasks.Task<TNewResult> ContinueWith<TNewResult> (Func<System.Threading.Tasks.Task<TResult>,object?,TNewResult> continuationFunction, object? state);

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

ArgumentNullException

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 State-Argument der ContinueWith(Action<Task,Object>, Object) -Methode bereit. Jeder DateTime Wert stellt den Zeitpunkt dar, zu dem die Continue-Aufgabe erstellt wird. Jede Aufgabe erzeugt als Ergebnis einen zweiten DateTime Wert, der den Zeitpunkt darstellt, zu dem der Vorgang abgeschlossen ist. Nachdem alle Aufgaben abgeschlossen sind, werden im Beispiel das Datum und die Uhrzeiten angezeigt, an denen die einzelnen Fortsetzungsaufgaben gestartet und abgeschlossen werden.

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

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.

Weitere Informationen

• Verketten von Aufgaben mithilfe von Fortsetzungsaufgaben

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

Quelle:

Future.cs

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

public System.Threading.Tasks.Task<TNewResult> ContinueWith<TNewResult> (Func<System.Threading.Tasks.Task<TResult>,TNewResult> continuationFunction);

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

ObjectDisposedException

Task<TResult> wurde verworfen.

ArgumentNullException

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

Weitere Informationen

• Task Parallel Library (TPL)
• Aufgabenbasierte asynchrone Programmierung
• Verketten von Aufgaben mithilfe von Fortsetzungsaufgaben

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

Quelle:

Future.cs

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

public System.Threading.Tasks.Task<TNewResult> ContinueWith<TNewResult> (Func<System.Threading.Tasks.Task<TResult>,TNewResult> continuationFunction, System.Threading.Tasks.TaskScheduler scheduler);

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

ObjectDisposedException

Task<TResult> wurde verworfen.

ArgumentNullException

Das continuationFunction-Argument lautet null.

- oder -

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.

Weitere Informationen

• TaskScheduler
• Task Parallel Library (TPL)
• Aufgabenbasierte asynchrone Programmierung
• Verketten von Aufgaben mithilfe von Fortsetzungsaufgaben