Task<TResult>.ContinueWith Metódus

Definíció

Névtér:

System.Threading.Tasks

Szerelvények:

netstandard.dll, System.Runtime.dll

Létrehoz egy folytatási feladatot, amely egy másik tevékenység befejezésekor fut.

Túlterhelések

Name	Description
ContinueWith(Action<Task<TResult>,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Létrehoz egy folytatást, amely a cél Task<TResult> befejeződésekor fut.
ContinueWith(Action<Task<TResult>,Object>, Object, TaskScheduler)	Létrehoz egy folytatást, amely a cél Task<TResult> befejeződésekor fut.
ContinueWith(Action<Task<TResult>,Object>, Object, TaskContinuationOptions)	Létrehoz egy folytatást, amely a cél Task<TResult> befejeződésekor fut.
ContinueWith(Action<Task<TResult>,Object>, Object, CancellationToken)	Létrehoz egy folytatást, amely a cél Task<TResult> befejeződésekor fut.
ContinueWith(Action<Task<TResult>>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Létrehoz egy folytatást, amely a megadott continuationOptionsfeltételnek megfelelően fut.
ContinueWith(Action<Task<TResult>>, TaskContinuationOptions)	Létrehoz egy folytatást, amely a megadott continuationOptionsfeltételnek megfelelően fut.
ContinueWith(Action<Task<TResult>>, CancellationToken)	Megszakítható folytatást hoz létre, amely a cél befejeződésekor aszinkron módon Task<TResult> fut.
ContinueWith(Action<Task<TResult>,Object>, Object)	Olyan folytatást hoz létre, amely átadta az állapotinformációkat, és a cél Task<TResult> befejeződésekor hajtja végre.
ContinueWith(Action<Task<TResult>>)	Létrehoz egy folytatást, amely aszinkron módon hajtja végre a céltevékenység befejezésekor.
ContinueWith(Action<Task<TResult>>, TaskScheduler)	Létrehoz egy folytatást, amely a cél befejeződésekor aszinkron módon Task<TResult> fut.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Létrehoz egy folytatást, amely a cél Task<TResult> befejeződésekor fut.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Létrehoz egy folytatást, amely a megadott continuationOptionsfeltételnek megfelelően fut.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, TaskScheduler)	Létrehoz egy folytatást, amely a cél Task<TResult> befejeződésekor fut.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, CancellationToken)	Létrehoz egy folytatást, amely a cél Task<TResult> befejeződésekor fut.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, TaskContinuationOptions)	Létrehoz egy folytatást, amely a cél Task<TResult> befejeződésekor fut.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, TaskContinuationOptions)	Létrehoz egy folytatást, amely a megadott continuationOptionsfeltételnek megfelelően fut.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, CancellationToken)	Létrehoz egy folytatást, amely a cél befejeződésekor aszinkron módon Task<TResult> fut.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object)	Létrehoz egy folytatást, amely a cél Task<TResult> befejeződésekor fut.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>)	Létrehoz egy folytatást, amely a cél befejeződésekor aszinkron módon Task<TResult> fut.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, TaskScheduler)	Létrehoz egy folytatást, amely a cél befejeződésekor aszinkron módon Task<TResult> fut.

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

Forrás:

Future.cs

Létrehoz egy folytatást, amely a cél Task<TResult> befejeződésekor fut.

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

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

Paraméterek

continuationAction

Action<Task<TResult>,Object>

A művelet végrehajtása után Task<TResult> futtatandó művelet. Futtatáskor a meghatalmazott átadja a befejezett feladatot és a hívó által megadott állapotobjektumot argumentumként.

state

Object

A folytatási művelet által használandó adatokat képviselő objektum.

cancellationToken

CancellationToken

Ez CancellationToken lesz hozzárendelve az új folytatási tevékenységhez.

continuationOptions

TaskContinuationOptions

A folytatás ütemezésének és viselkedésének beállításai. Ide tartoznak például OnlyOnCanceleda feltételek, valamint a végrehajtási lehetőségek, például ExecuteSynchronouslya .

scheduler

TaskScheduler

A TaskScheduler folytatási tevékenységhez társítandó és a végrehajtáshoz használandó.

Válaszok

Task

Egy új folytatás Task.

Kivételek

ArgumentNullException

Az scheduler argumentum a következő null: .

ArgumentOutOfRangeException

Az continuationOptions argumentum érvénytelen értéket ad meg a következőhöz TaskContinuationOptions: .

ObjectDisposedException

A megadottak CancellationToken már el lettek dobva.

Megjegyzések

A visszaadott Task feladat nem lesz végrehajtásra ütemezve, amíg az aktuális tevékenység be nem fejeződik. Ha a continuationOptions paraméterben megadott feltételek nem teljesülnek, a folytatási tevékenység az ütemezett helyett megszakad.

Lásd még

• Feladatok láncolása folytatási feladatok használatával

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

Forrás:

Future.cs

Létrehoz egy folytatást, amely a cél Task<TResult> befejeződésekor fut.

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

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

Paraméterek

continuationAction

Action<Task<TResult>,Object>

A művelet végrehajtása után Task<TResult> futtatandó művelet. Futtatáskor a meghatalmazott átadja a befejezett feladatot és a hívó által megadott állapotobjektumot argumentumként.

state

Object

A folytatási művelet által használandó adatokat képviselő objektum.

scheduler

TaskScheduler

A TaskScheduler folytatási tevékenységhez társítandó és a végrehajtáshoz használandó.

Válaszok

Task

Egy új folytatás Task.

Kivételek

ArgumentNullException

Az scheduler argumentum a következő null: .

Megjegyzések

A visszaadott Task feladat nem lesz végrehajtásra ütemezve, amíg az aktuális tevékenység be nem fejeződik, függetlenül attól, hogy a feladat sikeresen lefutott,nem kezelt kivétel miatt hibásodott-e meg, vagy a megszakítás miatt korán kilép.

Lásd még

• Feladatok láncolása folytatási feladatok használatával

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

Forrás:

Future.cs

Létrehoz egy folytatást, amely a cél Task<TResult> befejeződésekor fut.

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

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

Paraméterek

continuationAction

Action<Task<TResult>,Object>

A művelet végrehajtása után Task<TResult> futtatandó művelet. Futtatáskor a meghatalmazott átadja a befejezett feladatot és a hívó által megadott állapotobjektumot argumentumként.

state

Object

A folytatási művelet által használandó adatokat képviselő objektum.

continuationOptions

TaskContinuationOptions

A folytatás ütemezésének és viselkedésének beállításai. Ide tartoznak például OnlyOnCanceleda feltételek, valamint a végrehajtási lehetőségek, például ExecuteSynchronouslya .

Válaszok

Task

Egy új folytatás Task.

Kivételek

ArgumentNullException

Az continuationAction argumentum a következő null: .

ArgumentOutOfRangeException

Az continuationOptions argumentum érvénytelen értéket ad meg a következőhöz TaskContinuationOptions: .

Megjegyzések

A visszaadott Task feladat nem lesz végrehajtásra ütemezve, amíg az aktuális tevékenység be nem fejeződik. Ha a continuationOptions paraméterben megadott folytatási feltételek nem teljesülnek, a folytatási tevékenység nem ütemezett, hanem megszakítható.

Lásd még

• Feladatok láncolása folytatási feladatok használatával

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

Forrás:

Future.cs

Létrehoz egy folytatást, amely a cél Task<TResult> befejeződésekor fut.

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

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

Paraméterek

continuationAction

Action<Task<TResult>,Object>

A művelet végrehajtása után Task<TResult> futtatandó művelet. Futtatáskor a meghatalmazott átadja a befejezett feladatot és a hívó által megadott állapotobjektumot argumentumként.

state

Object

A folytatási művelet által használandó adatokat képviselő objektum.

cancellationToken

CancellationToken

Ez CancellationToken lesz hozzárendelve az új folytatási tevékenységhez.

Válaszok

Task

Egy új folytatás Task.

Kivételek

ArgumentNullException

Az continuationAction argumentum a következő null: .

ObjectDisposedException

A megadottak CancellationToken már el lettek dobva.

Megjegyzések

A visszaadott Task feladat nem lesz végrehajtásra ütemezve, amíg az aktuális tevékenység be nem fejeződik, függetlenül attól, hogy a feladat sikeresen lefutott,nem kezelt kivétel miatt hibásodott-e meg, vagy a megszakítás miatt korán kilép.

Lásd még

• Feladatok láncolása folytatási feladatok használatával

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

Forrás:

Future.cs

Létrehoz egy folytatást, amely a megadott continuationOptionsfeltételnek megfelelően fut.

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

Paraméterek

continuationAction

Action<Task<TResult>>

A megadott feltételnek continuationOptionsmegfelelően futtatandó művelet. Futtatáskor a meghatalmazott argumentumként átadja a befejezett feladatot.

cancellationToken

CancellationToken

Ez CancellationToken lesz hozzárendelve az új folytatási tevékenységhez.

continuationOptions

TaskContinuationOptions

A folytatás ütemezésének és viselkedésének beállításai. Ide tartoznak például OnlyOnCanceleda feltételek, valamint a végrehajtási lehetőségek, például ExecuteSynchronouslya .

scheduler

TaskScheduler

A TaskScheduler folytatási tevékenységhez társítandó és a végrehajtáshoz használandó.

Válaszok

Task

Egy új folytatás Task.

Kivételek

ObjectDisposedException

Az Task<TResult> el lett dobva.

-vagy-

A CancellationTokenSource létrehozott cancellationToken fájl már el lett adva.

ArgumentNullException

Az continuationAction argumentum a következő null: .

-vagy-

Az scheduler argumentum a következő null: .

ArgumentOutOfRangeException

Az continuationOptions argumentum érvénytelen értéket ad meg a következőhöz TaskContinuationOptions: .

Megjegyzések

A visszaadott Task feladat nem lesz végrehajtásra ütemezve, amíg az aktuális tevékenység be nem fejeződik. Ha a continuationOptions paraméterben megadott feltételek nem teljesülnek, a folytatási tevékenység az ütemezett helyett megszakad. További információért lásd: Feladatok láncolása folytatólagos tevékenységek használatával.

Lásd még

• Feladatpárhuzamosítási könyvtár (TPL)
• feladatalapú aszinkron programozás
• Feladatok láncolása folytatási feladatok használatával

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

Forrás:

Future.cs

Létrehoz egy folytatást, amely a megadott continuationOptionsfeltételnek megfelelően fut.

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

Paraméterek

continuationAction

Action<Task<TResult>>

A megadott feltételnek continuationOptionsmegfelelő művelet. Futtatáskor a meghatalmazott argumentumként átadja a befejezett feladatot.

continuationOptions

TaskContinuationOptions

A folytatás ütemezésének és viselkedésének beállításai. Ide tartoznak például OnlyOnCanceleda feltételek, valamint a végrehajtási lehetőségek, például ExecuteSynchronouslya .

Válaszok

Task

Egy új folytatás Task.

Kivételek

ObjectDisposedException

Az Task<TResult> el lett dobva.

ArgumentNullException

Az continuationAction argumentum a következő null: .

ArgumentOutOfRangeException

Az continuationOptions argumentum érvénytelen értéket ad meg a következőhöz TaskContinuationOptions: .

Megjegyzések

A visszaadott Task feladat nem lesz végrehajtásra ütemezve, amíg az aktuális tevékenység be nem fejeződik. Ha a continuationOptions paraméterben megadott folytatási feltételek nem teljesülnek, a folytatási tevékenység nem ütemezett, hanem megszakítható.

További információért lásd: Feladatok láncolása folytatólagos tevékenységek használatával.

Lásd még

• Feladatpárhuzamosítási könyvtár (TPL)
• feladatalapú aszinkron programozás
• Feladatok láncolása folytatási feladatok használatával

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

Forrás:

Future.cs

Megszakítható folytatást hoz létre, amely a cél befejeződésekor aszinkron módon Task<TResult> fut.

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

Paraméterek

continuationAction

Action<Task<TResult>>

A művelet végrehajtása után Task<TResult> futtatandó művelet. Futtatáskor a meghatalmazott argumentumként átadja a befejezett feladatot.

cancellationToken

CancellationToken

Az új folytatási feladatnak átadott lemondási jogkivonat.

Válaszok

Task

Új folytatási feladat.

Kivételek

ObjectDisposedException

Az Task<TResult> el lett dobva.

-vagy-

A CancellationTokenSource létrehozott cancellationToken fájl el lett adva.

ArgumentNullException

Az continuationAction argumentum a következő null: .

Példák

Az alábbi példa egy olyan előzményfeladatot hoz létre, amely az Eratosthenes szitát használja az 1 és a felhasználó által megadott érték közötti prímszámok kiszámításához. A tömbök a prímszámokkal kapcsolatos információk tárolására szolgálnak. A tömbindex a számot jelöli, az elem értéke pedig azt jelzi, hogy ez a szám összetett -e (értéke true) vagy prím (az értéke).false Ezt a feladatot ezután továbbadja egy folytatási tevékenységnek, amely az egész számtömbből kinyeri a prímszámokat, és megjeleníti őket.

A lemondási jogkivonat az előzménynek és a folytatási feladatnak is átadódik. Az System.Timers.Timer objektum 100 ezredmásodperc időtúllépési értékének meghatározására szolgál. Ha az esemény aktiválódik, a rendszer meghívja a CancellationTokenSource.Cancel metódust, és a lemondási jogkivonat a tevékenységek törlésének igénylésére szolgál.

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] ) {
                                      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] )
                                                        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.

Ha körülbelül 100 000 értéket ad meg, az időtúllépési időtartam lejár, az Timer.Elapsed esemény kigyullad, és a lemondási kérelem be lesz állítva.

Megjegyzések

A visszaadott Task feladat nem lesz végrehajtásra ütemezve, amíg az aktuális tevékenység be nem fejeződik, függetlenül attól, hogy a feladat sikeresen lefutott,nem kezelt kivétel miatt hibásodott-e meg, vagy a megszakítás miatt korán kilép.

Lásd még

• Feladatpárhuzamosítási könyvtár (TPL)
• feladatalapú aszinkron programozás
• Feladatok láncolása folytatási feladatok használatával

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

Forrás:

Future.cs

Olyan folytatást hoz létre, amely átadta az állapotinformációkat, és a cél Task<TResult> befejeződésekor hajtja végre.

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

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

Paraméterek

continuationAction

Action<Task<TResult>,Object>

A művelet végrehajtása után Task<TResult> futtatandó művelet. Futtatáskor a meghatalmazott átadja a befejezett feladatot és a hívó által megadott állapotobjektumot argumentumként.

state

Object

A folytatási művelet által használandó adatokat képviselő objektum.

Válaszok

Task

Egy új folytatás Task.

Kivételek

ArgumentNullException

Az continuationAction argumentum a következő null: .

Példák

Az alábbi példa létrehoz egy feladatot, amely 2 és 20 közötti egész számot ad vissza, és egy tömböt ad vissza, amely az első tíz kitevőt (n^1-től n^10-ig) tartalmazza. Ezután egy folytatási feladat felelős a kitevők megjelenítéséért. A rendszer az előtagot és az eredeti számot is átadja, amelynek kitevője az előtagot generálja.

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

Megjegyzések

A visszaadott Task feladat nem lesz végrehajtásra ütemezve, amíg az aktuális tevékenység be nem fejeződik, függetlenül attól, hogy a feladat sikeresen lefutott,nem kezelt kivétel miatt hibásodott-e meg, vagy a megszakítás miatt korán kilép.

Lásd még

• Feladatok láncolása folytatási feladatok használatával

ContinueWith(Action<Task<TResult>>)

Forrás:

Future.cs

Létrehoz egy folytatást, amely aszinkron módon hajtja végre a céltevékenység befejezésekor.

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

Paraméterek

continuationAction

Action<Task<TResult>>

Az előzmény Task<TResult> befejeződésekor futtatandó művelet. Futtatáskor a meghatalmazott argumentumként átadja a befejezett feladatot.

Válaszok

Task

Új folytatási feladat.

Kivételek

ObjectDisposedException

Az Task<TResult> el lett dobva.

ArgumentNullException

Az continuationAction argumentum a következő null: .

Példák

Az alábbi példa egy olyan előzményfeladatot hoz létre, amely az Eratosthenes szitát használja az 1 és a felhasználó által megadott érték közötti prímszámok kiszámításához. A tömbök a prímszámokkal kapcsolatos információk tárolására szolgálnak. A tömbindex a számot jelöli, az elem értéke pedig azt jelzi, hogy ez a szám összetett -e (értéke true) vagy prím (az értéke).false Ezt a feladatot ezután továbbadja egy folytatási tevékenységnek, amely az egész számtömbből kinyeri a prímszámokat, és megjeleníti őket.

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]) {
                                      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])
                                                        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.

Megjegyzések

A visszaadott Task feladat nem lesz végrehajtásra ütemezve, amíg az aktuális tevékenység be nem fejeződik, függetlenül attól, hogy a feladat sikeresen lefutott,nem kezelt kivétel miatt hibásodott-e meg, vagy a megszakítás miatt korán befejeződött.

Lásd még

• Feladatpárhuzamosítási könyvtár (TPL)
• feladatalapú aszinkron programozás
• Feladatok láncolása folytatási feladatok használatával

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

Forrás:

Future.cs

Létrehoz egy folytatást, amely a cél befejeződésekor aszinkron módon Task<TResult> fut.

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

Paraméterek

continuationAction

Action<Task<TResult>>

A művelet végrehajtása után Task<TResult> futtatandó művelet. Futtatáskor a meghatalmazott argumentumként átadja a befejezett feladatot.

scheduler

TaskScheduler

A TaskScheduler folytatási tevékenységhez társítandó és a végrehajtáshoz használandó.

Válaszok

Task

Egy új folytatás Task.

Kivételek

ObjectDisposedException

Az Task<TResult> el lett dobva.

ArgumentNullException

Az continuationAction argumentum a következő null: .

-vagy-

Az scheduler argumentum a következő null: .

Megjegyzések

A visszaadott Task feladat nem lesz végrehajtásra ütemezve, amíg az aktuális tevékenység be nem fejeződik, függetlenül attól, hogy a feladat sikeresen lefutott,nem kezelt kivétel miatt hibásodott-e meg, vagy a megszakítás miatt korán kilép.

Lásd még

• Feladatpárhuzamosítási könyvtár (TPL)
• feladatalapú aszinkron programozás
• Feladatok láncolása folytatási feladatok használatával

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

Forrás:

Future.cs

Létrehoz egy folytatást, amely a cél Task<TResult> befejeződésekor fut.

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

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)

Típusparaméterek

TNewResult

A folytatás által előállított eredmény típusa.

Paraméterek

continuationFunction

Func<Task<TResult>,Object,TNewResult>

A befejezett állapotban Task<TResult> futtatandó függvény. Futtatáskor a meghatalmazott átadja a befejezett feladatot és a hívó által megadott állapotobjektumot argumentumként.

state

Object

A folytatási függvény által használandó adatokat képviselő objektum.

cancellationToken

CancellationToken

Ez CancellationToken lesz hozzárendelve az új tevékenységhez.

continuationOptions

TaskContinuationOptions

A folytatás ütemezésének és viselkedésének beállításai. Ide tartoznak például OnlyOnCanceleda feltételek, valamint a végrehajtási lehetőségek, például ExecuteSynchronouslya .

scheduler

TaskScheduler

A TaskScheduler folytatási tevékenységhez társítandó és a végrehajtáshoz használandó.

Válaszok

Task<TNewResult>

Egy új folytatás Task<TResult>.

Kivételek

ArgumentNullException

Az scheduler argumentum a következő null: .

ArgumentOutOfRangeException

Az continuationOptions argumentum érvénytelen értéket ad meg a következőhöz TaskContinuationOptions: .

ObjectDisposedException

A megadottak CancellationToken már el lettek dobva.

Megjegyzések

A visszaadott Task<TResult> feladat nem lesz végrehajtásra ütemezve, amíg az aktuális tevékenység be nem fejeződik, függetlenül attól, hogy a feladat sikeresen lefutott,nem kezelt kivétel miatt hibásodott-e meg, vagy a megszakítás miatt korán kilép.

A continuationFunctionvégrehajtáskor a Task<TResult>. Ennek a tevékenységnek a befejezési állapota át lesz adva a hívásból visszaadott tevékenységre Task<TResult>.ContinueWith .

Lásd még

• Feladatok láncolása folytatási feladatok használatával

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

Forrás:

Future.cs

Létrehoz egy folytatást, amely a megadott continuationOptionsfeltételnek megfelelően fut.

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)

Típusparaméterek

TNewResult

A folytatás által előállított eredmény típusa.

Paraméterek

continuationFunction

Func<Task<TResult>,TNewResult>

A megadott feltételnek continuationOptionsmegfelelően futtatandó függvény.

Futtatáskor a program argumentumként átadja a meghatalmazottnak ezt a befejezett feladatot.

cancellationToken

CancellationToken

Ez CancellationToken lesz hozzárendelve az új tevékenységhez.

continuationOptions

TaskContinuationOptions

A folytatás ütemezésének és viselkedésének beállításai. Ide tartoznak például OnlyOnCanceleda feltételek, valamint a végrehajtási lehetőségek, például ExecuteSynchronouslya .

scheduler

TaskScheduler

A TaskScheduler folytatási tevékenységhez társítandó és a végrehajtáshoz használandó.

Válaszok

Task<TNewResult>

Egy új folytatás Task<TResult>.

Kivételek

ObjectDisposedException

Az Task<TResult> el lett dobva.

-vagy-

A CancellationTokenSource létrehozott cancellationToken fájl már el lett adva.

ArgumentNullException

Az continuationFunction argumentum a következő null: .

-vagy-

Az scheduler argumentum a következő null: .

ArgumentOutOfRangeException

Az continuationOptions argumentum érvénytelen értéket ad meg a következőhöz TaskContinuationOptions: .

Megjegyzések

A visszaadott Task<TResult> feladat nem lesz végrehajtásra ütemezve, amíg az aktuális tevékenység be nem fejeződik, függetlenül attól, hogy a feladat sikeresen lefutott,nem kezelt kivétel miatt hibásodott-e meg, vagy a megszakítás miatt korán kilép.

A continuationFunctionvégrehajtáskor a Task<TResult>.

Lásd még

• Feladatpárhuzamosítási könyvtár (TPL)
• feladatalapú aszinkron programozás
• Feladatok láncolása folytatási feladatok használatával

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

Forrás:

Future.cs

Létrehoz egy folytatást, amely a cél Task<TResult> befejeződésekor fut.

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

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)

Típusparaméterek

TNewResult

A folytatás által előállított eredmény típusa.

Paraméterek

continuationFunction

Func<Task<TResult>,Object,TNewResult>

A befejezett állapotban Task<TResult> futtatandó függvény. Futtatáskor a meghatalmazott átadja a befejezett feladatot és a hívó által megadott állapotobjektumot argumentumként.

state

Object

A folytatási függvény által használandó adatokat képviselő objektum.

scheduler

TaskScheduler

A TaskScheduler folytatási tevékenységhez társítandó és a végrehajtáshoz használandó.

Válaszok

Task<TNewResult>

Egy új folytatás Task<TResult>.

Kivételek

ArgumentNullException

Az scheduler argumentum a következő null: .

Megjegyzések

A visszaadott Task<TResult> feladat nem lesz végrehajtásra ütemezve, amíg az aktuális tevékenység be nem fejeződik, függetlenül attól, hogy a feladat sikeresen lefutott,nem kezelt kivétel miatt hibásodott-e meg, vagy a megszakítás miatt korán kilép.

Lásd még

• Feladatok láncolása folytatási feladatok használatával

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

Forrás:

Future.cs

Létrehoz egy folytatást, amely a cél Task<TResult> befejeződésekor fut.

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

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)

Típusparaméterek

TNewResult

A folytatás által előállított eredmény típusa.

Paraméterek

continuationFunction

Func<Task<TResult>,Object,TNewResult>

A befejezett állapotban Task<TResult> futtatandó függvény. Futtatáskor a meghatalmazott átadja a befejezett feladatot és a hívó által megadott állapotobjektumot argumentumként.

state

Object

A folytatási függvény által használandó adatokat képviselő objektum.

cancellationToken

CancellationToken

Ez CancellationToken lesz hozzárendelve az új tevékenységhez.

Válaszok

Task<TNewResult>

Egy új folytatás Task<TResult>.

Kivételek

ArgumentNullException

Az continuationFunction argumentum a következő null: .

ObjectDisposedException

A megadottak CancellationToken már el lettek dobva.

Megjegyzések

A visszaadott Task<TResult> feladat nem lesz végrehajtásra ütemezve, amíg az aktuális tevékenység be nem fejeződik, függetlenül attól, hogy a feladat sikeresen lefutott,nem kezelt kivétel miatt hibásodott-e meg, vagy a megszakítás miatt korán kilép.

Lásd még

• Feladatok láncolása folytatási feladatok használatával

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

Forrás:

Future.cs

Létrehoz egy folytatást, amely a cél Task<TResult> befejeződésekor fut.

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

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)

Típusparaméterek

TNewResult

A folytatás által előállított eredmény típusa.

Paraméterek

continuationFunction

Func<Task<TResult>,Object,TNewResult>

A befejezett állapotban Task<TResult> futtatandó függvény. Futtatáskor a meghatalmazott átadja a befejezett feladatot és a hívó által megadott állapotobjektumot argumentumként.

state

Object

A folytatási függvény által használandó adatokat képviselő objektum.

continuationOptions

TaskContinuationOptions

A folytatás ütemezésének és viselkedésének beállításai. Ide tartoznak például OnlyOnCanceleda feltételek, valamint a végrehajtási lehetőségek, például ExecuteSynchronouslya .

Válaszok

Task<TNewResult>

Egy új folytatás Task<TResult>.

Kivételek

ArgumentNullException

Az continuationFunction argumentum a következő null: .

ArgumentOutOfRangeException

Az continuationOptions argumentum érvénytelen értéket ad meg a következőhöz TaskContinuationOptions: .

Megjegyzések

A visszaadott Task<TResult> feladat nem lesz végrehajtásra ütemezve, amíg az aktuális tevékenység be nem fejeződik, függetlenül attól, hogy a feladat sikeresen lefutott,nem kezelt kivétel miatt hibásodott-e meg, vagy a megszakítás miatt korán kilép.

A continuationFunctionvégrehajtáskor a Task<TResult>. Ennek a tevékenységnek a befejezési állapota át lesz adva a ContinueWith hívásból visszaadott tevékenységre.

Lásd még

• Feladatok láncolása folytatási feladatok használatával

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

Forrás:

Future.cs

Létrehoz egy folytatást, amely a megadott continuationOptionsfeltételnek megfelelően fut.

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)

Típusparaméterek

TNewResult

A folytatás által előállított eredmény típusa.

Paraméterek

continuationFunction

Func<Task<TResult>,TNewResult>

A megadott feltételnek continuationOptionsmegfelelően futtatandó függvény.

Futtatáskor a meghatalmazott argumentumként átadja a befejezett feladatot.

continuationOptions

TaskContinuationOptions

A folytatás ütemezésének és viselkedésének beállításai. Ide tartoznak például OnlyOnCanceleda feltételek, valamint a végrehajtási lehetőségek, például ExecuteSynchronouslya .

Válaszok

Task<TNewResult>

Egy új folytatás Task<TResult>.

Kivételek

ObjectDisposedException

Az Task<TResult> el lett dobva.

ArgumentNullException

Az continuationFunction argumentum a következő null: .

ArgumentOutOfRangeException

Az continuationOptions argumentum érvénytelen értéket ad meg a következőhöz TaskContinuationOptions: .

Megjegyzések

A visszaadott Task<TResult> feladat nem lesz végrehajtásra ütemezve, amíg az aktuális tevékenység be nem fejeződik, függetlenül attól, hogy a feladat sikeresen lefutott,nem kezelt kivétel miatt hibásodott-e meg, vagy a megszakítás miatt korán kilép.

A continuationFunctionvégrehajtáskor a Task<TResult>.

Lásd még

• Feladatpárhuzamosítási könyvtár (TPL)
• feladatalapú aszinkron programozás
• Feladatok láncolása folytatási feladatok használatával

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

Forrás:

Future.cs

Létrehoz egy folytatást, amely a cél befejeződésekor aszinkron módon Task<TResult> fut.

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)

Típusparaméterek

TNewResult

A folytatás által előállított eredmény típusa.

Paraméterek

continuationFunction

Func<Task<TResult>,TNewResult>

A befejezett állapotban Task<TResult> futtatandó függvény. Futtatáskor a meghatalmazott argumentumként átadja a befejezett feladatot.

cancellationToken

CancellationToken

Ez CancellationToken lesz hozzárendelve az új tevékenységhez.

Válaszok

Task<TNewResult>

Egy új folytatás Task<TResult>.

Kivételek

ObjectDisposedException

Az Task<TResult> el lett dobva.

-vagy-

A CancellationTokenSource létrehozott cancellationToken fájl már el lett adva.

ArgumentNullException

Az continuationFunction argumentum a következő null: .

Megjegyzések

A visszaadott Task<TResult> feladat nem lesz végrehajtásra ütemezve, amíg az aktuális tevékenység be nem fejeződik, függetlenül attól, hogy a feladat sikeresen lefutott,nem kezelt kivétel miatt hibásodott-e meg, vagy a megszakítás miatt korán kilép.

Lásd még

• Feladatpárhuzamosítási könyvtár (TPL)
• feladatalapú aszinkron programozás
• Feladatok láncolása folytatási feladatok használatával

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

Forrás:

Future.cs

Létrehoz egy folytatást, amely a cél Task<TResult> befejeződésekor fut.

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

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)

Típusparaméterek

TNewResult

A folytatás által előállított eredmény típusa.

Paraméterek

continuationFunction

Func<Task<TResult>,Object,TNewResult>

A befejezett állapotban Task<TResult> futtatandó függvény. Futtatáskor a meghatalmazott átadja a befejezett feladatot és a hívó által megadott állapotobjektumot argumentumként.

state

Object

A folytatási függvény által használandó adatokat képviselő objektum.

Válaszok

Task<TNewResult>

Egy új folytatás Task<TResult>.

Kivételek

ArgumentNullException

Az continuationFunction argumentum a következő null: .

Példák

Az alábbi példa a folytatási tevékenységek láncát hozza létre. Minden tevékenység a metódus állapotargumentumához megadja az aktuális időt, egy DateTime objektumot ContinueWith(Action<Task,Object>, Object) . Minden DateTime érték azt az időpontot jelöli, amikor a folytatási tevékenység létrejön. Minden tevékenység eredménye egy második DateTime érték, amely a tevékenység befejezésének időpontját jelöli. Az összes tevékenység befejezése után a példa megjeleníti azokat a dátumokat és időpontokat, amelyeken az egyes folytatási tevékenységek elindulnak és befejeződnek.

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.

Megjegyzések

A visszaadott Task<TResult> feladat nem lesz végrehajtásra ütemezve, amíg az aktuális tevékenység be nem fejeződik, függetlenül attól, hogy a feladat sikeresen lefutott,nem kezelt kivétel miatt hibásodott-e meg, vagy a megszakítás miatt korán kilép.

Lásd még

• Feladatok láncolása folytatási feladatok használatával

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

Forrás:

Future.cs

Létrehoz egy folytatást, amely a cél befejeződésekor aszinkron módon Task<TResult> fut.

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)

Típusparaméterek

TNewResult

A folytatás által előállított eredmény típusa.

Paraméterek

continuationFunction

Func<Task<TResult>,TNewResult>

A befejezett állapotban Task<TResult> futtatandó függvény. Futtatáskor a meghatalmazott argumentumként átadja a befejezett feladatot.

Válaszok

Task<TNewResult>

Egy új folytatás Task<TResult>.

Kivételek

ObjectDisposedException

Az Task<TResult> el lett dobva.

ArgumentNullException

Az continuationFunction argumentum a következő null: .

Megjegyzések

A visszaadott Task<TResult> feladat nem lesz végrehajtásra ütemezve, amíg az aktuális tevékenység be nem fejeződik, függetlenül attól, hogy a feladat sikeresen lefutott,nem kezelt kivétel miatt hibásodott-e meg, vagy a megszakítás miatt korán kilép.

Lásd még

• Feladatpárhuzamosítási könyvtár (TPL)
• feladatalapú aszinkron programozás
• Feladatok láncolása folytatási feladatok használatával

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

Forrás:

Future.cs

Létrehoz egy folytatást, amely a cél befejeződésekor aszinkron módon Task<TResult> fut.

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)

Típusparaméterek

TNewResult

A folytatás által előállított eredmény típusa.

Paraméterek

continuationFunction

Func<Task<TResult>,TNewResult>

A befejezett állapotban Task<TResult> futtatandó függvény. Futtatáskor a meghatalmazott argumentumként átadja a befejezett feladatot.

scheduler

TaskScheduler

A TaskScheduler folytatási tevékenységhez társítandó és a végrehajtáshoz használandó.

Válaszok

Task<TNewResult>

Egy új folytatás Task<TResult>.

Kivételek

ObjectDisposedException

Az Task<TResult> el lett dobva.

ArgumentNullException

Az continuationFunction argumentum a következő null: .

-vagy-

Az scheduler argumentum a következő null: .

Megjegyzések

A visszaadott Task<TResult> feladat nem lesz végrehajtásra ütemezve, amíg az aktuális tevékenység be nem fejeződik, függetlenül attól, hogy a feladat sikeresen lefutott,nem kezelt kivétel miatt hibásodott-e meg, vagy a megszakítás miatt korán kilép.

Lásd még

• TaskScheduler
• Feladatpárhuzamosítási könyvtár (TPL)
• feladatalapú aszinkron programozás
• Feladatok láncolása folytatási feladatok használatával