Task<TResult>.ContinueWith Task<TResult>.ContinueWith Task<TResult>.ContinueWith Task<TResult>.ContinueWith Method

Definition

Erstellt eine Fortsetzungsaufgabe, die ausgeführt wird, wenn eine andere Aufgabe beendet ist.Creates a continuation task that executes when another task completes.

Überlädt

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

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.Creates a continuation that executes when the target Task<TResult> completes.

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

Erstellt eine Fortsetzung, die nach der in continuationOptions angegebenen Bedingung ausgeführt wird.Creates a continuation that executes according the condition specified in continuationOptions.

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

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.Creates a continuation that executes when the target Task<TResult> completes.

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

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.Creates a continuation that executes when the target Task<TResult> completes.

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

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.Creates a continuation that executes when the target Task<TResult> completes.

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

Erstellt eine Fortsetzung, die nach der in continuationOptions angegebenen Bedingung ausgeführt wird.Creates a continuation that executes according the condition specified in continuationOptions.

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

Erstellt eine abzubrechende Fortsetzung, die asynchron ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen wurde.Creates a cancelable continuation that executes asynchronously when the target Task<TResult> completes.

ContinueWith(Action<Task<TResult>,Object>, Object) ContinueWith(Action<Task<TResult>,Object>, Object) ContinueWith(Action<Task<TResult>,Object>, Object) 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.Creates a continuation that is passed state information and that executes when the target Task<TResult> completes.

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

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn die Zielaufgabe abgeschlossen wurde.Creates a continuation that executes asynchronously when the target task completes.

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

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task<TResult> abgeschlossen wurde.Creates a continuation that executes asynchronously when the target Task<TResult> completes.

ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler) ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler) 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.Creates a continuation that executes when the target Task<TResult> completes.

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

Erstellt eine Fortsetzung, die nach der in continuationOptions angegebenen Bedingung ausgeführt wird.Creates a continuation that executes according the condition specified in continuationOptions.

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

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.Creates a continuation that executes when the target Task<TResult> completes.

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

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.Creates a continuation that executes when the target Task<TResult> completes.

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

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.Creates a continuation that executes when the target Task<TResult> completes.

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

Erstellt eine Fortsetzung, die nach der in continuationOptions angegebenen Bedingung ausgeführt wird.Creates a continuation that executes according the condition specified in continuationOptions.

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

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task<TResult> abgeschlossen wurde.Creates a continuation that executes asynchronously when the target Task<TResult> completes.

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

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.Creates a continuation that executes when the target Task<TResult> completes.

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

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task<TResult> abgeschlossen wurde.Creates a continuation that executes asynchronously when the target Task<TResult> completes.

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

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task<TResult> abgeschlossen wurde.Creates a continuation that executes asynchronously when the target Task<TResult> completes.

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

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.Creates a continuation that executes when the target Task<TResult> completes.

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

Parameter

continuationAction
Action<Task<TResult>,Object>

Eine Aktion, die beim Abschluss von Task<TResult> ausgeführt werden soll.An action to run when the Task<TResult> completes. Bei der Ausführung werden dem Delegaten die abgeschlossene Aufgabe und das vom Aufrufer angegebene Zustandsobjekt als Argumente übergeben.When run, the delegate will be passed the completed task and the caller-supplied state object as arguments.

state
Object Object Object Object

Ein Objekt, das Daten darstellt, die von der Fortsetzungsaktion verwendet werden sollen.An object representing data to be used by the continuation action.

cancellationToken
CancellationToken CancellationToken CancellationToken CancellationToken

Das CancellationToken, das der neuen Fortsetzungsaufgabe zugewiesen wird.The CancellationToken that will be assigned to the new continuation task.

continuationOptions
TaskContinuationOptions TaskContinuationOptions TaskContinuationOptions TaskContinuationOptions

Optionen für die Planung und das Verhalten der Fortsetzung.Options for when the continuation is scheduled and how it behaves. Dazu zählen Kriterien wie OnlyOnCanceled und Ausführungsoptionen wie ExecuteSynchronously.This includes criteria, such as OnlyOnCanceled, as well as execution options, such as ExecuteSynchronously.

scheduler
TaskScheduler TaskScheduler TaskScheduler TaskScheduler

Der TaskScheduler, der der Fortsetzungsaufgabe zugeordnet und für ihre Ausführung verwendet werden soll.The TaskScheduler to associate with the continuation task and to use for its execution.

Gibt zurück

Ein neuer Fortsetzungs-Task.A new continuation Task.

Ausnahmen

Das scheduler-Argument ist null.The scheduler argument is null.

Das continuationOptions-Argument gibt einen ungültigen Wert für TaskContinuationOptions an.The continuationOptions argument specifies an invalid value for TaskContinuationOptions.

Das angegebene CancellationToken wurde bereits freigegeben.The provided CancellationToken has already been disposed.

Hinweise

Das zurückgegebene Task wird nicht für die Ausführung geplant werden, bis der aktuelle Task abgeschlossen ist.The returned Task will not be scheduled for execution until the current task has completed. Wenn die Kriterien, über angegeben die continuationOptions Parameter sind nicht erfüllt werden, das der Fortsetzungsaufgabe wird abgebrochen statt geplant.If the criteria specified through the continuationOptions parameter are not met, the continuation task will be canceled instead of scheduled.

Siehe auch

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

Erstellt eine Fortsetzung, die nach der in continuationOptions angegebenen Bedingung ausgeführt wird.Creates a continuation that executes according the condition specified in continuationOptions.

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

Parameter

continuationAction
Action<Task<TResult>>

Eine Aktion, die entsprechend der in continuationOptions angegebenen Bedingung ausgeführt wird.An action to run according the condition specified in continuationOptions. Bei der Ausführung wird dem Delegaten die abgeschlossene Aufgabe als Argument übergeben.When run, the delegate will be passed the completed task as an argument.

cancellationToken
CancellationToken CancellationToken CancellationToken CancellationToken

Das CancellationToken, das der neuen Fortsetzungsaufgabe zugewiesen wird.The CancellationToken that will be assigned to the new continuation task.

continuationOptions
TaskContinuationOptions TaskContinuationOptions TaskContinuationOptions TaskContinuationOptions

Optionen für die Planung und das Verhalten der Fortsetzung.Options for when the continuation is scheduled and how it behaves. Dazu zählen Kriterien wie OnlyOnCanceled und Ausführungsoptionen wie ExecuteSynchronously.This includes criteria, such as OnlyOnCanceled, as well as execution options, such as ExecuteSynchronously.

scheduler
TaskScheduler TaskScheduler TaskScheduler TaskScheduler

Das TaskScheduler, das der Fortsetzungsaufgabe zugeordnet und für ihre Ausführung verwendet werden soll.The TaskScheduler to associate with the continuation task and to use for its execution.

Gibt zurück

Ein neuer Fortsetzungs-Task.A new continuation Task.

Ausnahmen

Task<TResult> wurde verworfen.The Task<TResult> has been disposed.

- oder --or- Die CancellationTokenSource, die cancellationToken erstellt hat, wurde bereits freigegeben.The CancellationTokenSource that created cancellationToken has already been disposed.

Das continuationAction-Argument ist null.The continuationAction argument is null.

- oder --or- Das scheduler-Argument ist null.The scheduler argument is null.

Das continuationOptions-Argument gibt einen ungültigen Wert für TaskContinuationOptions an.The continuationOptions argument specifies an invalid value for TaskContinuationOptions.

Hinweise

Das zurückgegebene Task wird nicht für die Ausführung geplant werden, bis der aktuelle Task abgeschlossen ist.The returned Task will not be scheduled for execution until the current task has completed. Wenn die Kriterien, über angegeben die continuationOptions Parameter sind nicht erfüllt werden, das der Fortsetzungsaufgabe wird abgebrochen statt geplant.If the criteria specified through the continuationOptions parameter are not met, the continuation task will be canceled instead of scheduled. Weitere Informationen finden Sie unter Verketten von Aufgaben mithilfe von Fortsetzungsaufgaben.For more information, see Chaining Tasks by Using Continuation Tasks.

Siehe auch

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

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.Creates a continuation that executes when the target Task<TResult> completes.

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

Parameter

continuationAction
Action<Task<TResult>,Object>

Eine Aktion, die beim Abschluss von Task<TResult> ausgeführt werden soll.An action to run when the Task<TResult> completes. Bei der Ausführung werden dem Delegaten die abgeschlossene Aufgabe und das vom Aufrufer angegebene Zustandsobjekt als Argumente übergeben.When run, the delegate will be passed the completed task and the caller-supplied state object as arguments.

state
Object Object Object Object

Ein Objekt, das Daten darstellt, die von der Fortsetzungsaktion verwendet werden sollen.An object representing data to be used by the continuation action.

scheduler
TaskScheduler TaskScheduler TaskScheduler TaskScheduler

Das TaskScheduler, das der Fortsetzungsaufgabe zugeordnet und für ihre Ausführung verwendet werden soll.The TaskScheduler to associate with the continuation task and to use for its execution.

Gibt zurück

Ein neuer Fortsetzungs-Task.A new continuation Task.

Ausnahmen

Das scheduler-Argument lautet null.The scheduler argument is null.

Hinweise

Das zurückgegebene Task wird nicht zur Ausführung geplant werden erst nach Abschluss die aktuelle Aufgabe, ob der Vorgang aufgrund von erfolgreich ausgeführt, Fehler aufgrund eines Ausnahmefehlers oder beenden Sie frühzeitig aufgrund eines Abbruchs abgeschlossen ist.The returned Task will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

Siehe auch

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

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.Creates a continuation that executes when the target Task<TResult> completes.

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

Parameter

continuationAction
Action<Task<TResult>,Object>

Eine Aktion, die beim Abschluss von Task<TResult> ausgeführt werden soll.An action to run when the Task<TResult> completes. Bei der Ausführung werden dem Delegaten die abgeschlossene Aufgabe und das vom Aufrufer angegebene Zustandsobjekt als Argumente übergeben.When run, the delegate will be passed the completed task and the caller-supplied state object as arguments.

state
Object Object Object Object

Ein Objekt, das Daten darstellt, die von der Fortsetzungsaktion verwendet werden sollen.An object representing data to be used by the continuation action.

cancellationToken
CancellationToken CancellationToken CancellationToken CancellationToken

Das CancellationToken, das der neuen Fortsetzungsaufgabe zugewiesen wird.The CancellationToken that will be assigned to the new continuation task.

Gibt zurück

Ein neuer Fortsetzungs-Task.A new continuation Task.

Ausnahmen

Das continuationAction-Argument ist null.The continuationAction argument is null.

Das angegebene CancellationToken wurde bereits freigegeben.The provided CancellationToken has already been disposed.

Hinweise

Das zurückgegebene Task wird nicht zur Ausführung geplant werden erst nach Abschluss die aktuelle Aufgabe, ob der Vorgang aufgrund von erfolgreich ausgeführt, Fehler aufgrund eines Ausnahmefehlers oder beenden Sie frühzeitig aufgrund eines Abbruchs abgeschlossen ist.The returned Task will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

Siehe auch

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

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.Creates a continuation that executes when the target Task<TResult> completes.

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

Parameter

continuationAction
Action<Task<TResult>,Object>

Eine Aktion, die beim Abschluss von Task<TResult> ausgeführt werden soll.An action to run when the Task<TResult> completes. Bei der Ausführung werden dem Delegaten die abgeschlossene Aufgabe und das vom Aufrufer angegebene Zustandsobjekt als Argumente übergeben.When run, the delegate will be passed the completed task and the caller-supplied state object as arguments.

state
Object Object Object Object

Ein Objekt, das Daten darstellt, die von der Fortsetzungsaktion verwendet werden sollen.An object representing data to be used by the continuation action.

continuationOptions
TaskContinuationOptions TaskContinuationOptions TaskContinuationOptions TaskContinuationOptions

Optionen für die Planung und das Verhalten der Fortsetzung.Options for when the continuation is scheduled and how it behaves. Dazu zählen Kriterien wie OnlyOnCanceled und Ausführungsoptionen wie ExecuteSynchronously.This includes criteria, such as OnlyOnCanceled, as well as execution options, such as ExecuteSynchronously.

Gibt zurück

Ein neuer Fortsetzungs-Task.A new continuation Task.

Ausnahmen

Das continuationAction-Argument ist null.The continuationAction argument is null.

Das continuationOptions-Argument gibt einen ungültigen Wert für TaskContinuationOptions an.The continuationOptions argument specifies an invalid value for TaskContinuationOptions.

Hinweise

Das zurückgegebene Task wird nicht für die Ausführung geplant werden, bis der aktuelle Task abgeschlossen ist.The returned Task will not be scheduled for execution until the current task has completed. Wenn die Fortsetzungskriterien über angegeben die continuationOptions Parameter sind nicht erfüllt werden, das der Fortsetzungsaufgabe wird jedoch abgebrochen statt geplant.If the continuation criteria specified through the continuationOptions parameter are not met, the continuation task will be canceled instead of scheduled.

Siehe auch

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

Erstellt eine Fortsetzung, die nach der in continuationOptions angegebenen Bedingung ausgeführt wird.Creates a continuation that executes according the condition specified in continuationOptions.

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

Parameter

continuationAction
Action<Task<TResult>>

Eine Aktion entsprechend der in continuationOptions angegebenen Bedingung.An action to according the condition specified in continuationOptions. Bei der Ausführung wird dem Delegaten die abgeschlossene Aufgabe als Argument übergeben.When run, the delegate will be passed the completed task as an argument.

continuationOptions
TaskContinuationOptions TaskContinuationOptions TaskContinuationOptions TaskContinuationOptions

Optionen für die Planung und das Verhalten der Fortsetzung.Options for when the continuation is scheduled and how it behaves. Dazu zählen Kriterien wie OnlyOnCanceled und Ausführungsoptionen wie ExecuteSynchronously.This includes criteria, such as OnlyOnCanceled, as well as execution options, such as ExecuteSynchronously.

Gibt zurück

Ein neuer Fortsetzungs-Task.A new continuation Task.

Ausnahmen

Das continuationAction-Argument ist null.The continuationAction argument is null.

Das continuationOptions-Argument gibt einen ungültigen Wert für TaskContinuationOptions an.The continuationOptions argument specifies an invalid value for TaskContinuationOptions.

Hinweise

Das zurückgegebene Task wird nicht für die Ausführung geplant werden, bis der aktuelle Task abgeschlossen ist.The returned Task will not be scheduled for execution until the current task has completed. Wenn die Fortsetzungskriterien über angegeben die continuationOptions Parameter sind nicht erfüllt werden, das der Fortsetzungsaufgabe wird jedoch abgebrochen statt geplant.If the continuation criteria specified through the continuationOptions parameter are not met, the continuation task will be canceled instead of scheduled.

Weitere Informationen finden Sie unter Verketten von Aufgaben mithilfe von Fortsetzungsaufgaben.For more information, see Chaining Tasks by Using Continuation Tasks.

Siehe auch

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

Erstellt eine abzubrechende Fortsetzung, die asynchron ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen wurde.Creates a cancelable continuation that executes asynchronously when the target Task<TResult> completes.

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

Parameter

continuationAction
Action<Task<TResult>>

Eine Aktion, die beim Abschluss von Task<TResult> ausgeführt werden soll.An action to run when the Task<TResult> completes. Bei der Ausführung wird dem Delegaten die abgeschlossene Aufgabe als Argument übergeben.When run, the delegate is passed the completed task as an argument.

cancellationToken
CancellationToken CancellationToken CancellationToken CancellationToken

Das Abbruchtoken, das an die neue Fortsetzungsaufgabe übergeben werden soll.The cancellation token that is passed to the new continuation task.

Gibt zurück

Eine neue Fortsetzungsaufgabe.A new continuation task.

Ausnahmen

Task<TResult> wurde verworfen.The Task<TResult> has been disposed.

- oder --or- Die CancellationTokenSource, die cancellationToken erstellt hat, wurde gelöscht.The CancellationTokenSource that created cancellationToken has been disposed.

Das continuationAction-Argument lautet null.The continuationAction argument is null.

Beispiele

Das folgende Beispiel erstellt eine Vorgängeraufgabe, die das Sieb des Eratosthenes zum Berechnen von Primzahlen zwischen 1 und vom Benutzer eingegebene Wert verwendet.The following example creates an antecedent task that uses the Sieve of Eratosthenes to calculate the prime numbers between 1 and a value entered by the user. Ein Array ist zum Speichern von Informationen über die Primzahlen verwendet.An array is used to hold information about the prime numbers. Index des Arrays darstellt, die Anzahl und den Wert des Elements angibt, ob diese Zahl zusammengesetzt ist (der Wert ist true) oder vorzubereiten (der Wert ist false).The array index represents the number, and the element's value indicates whether that number is composite (its value is true) or prime (its value is false). Diese Aufgabe wird dann an eine Fortsetzungsaufgabe übergeben, die für die Primzahlen aus einem Ganzzahlen-Array zu extrahieren und zu deren Anzeige zuständig ist.This task is then passed to a continuation task, which is responsible for extracting the prime numbers from the integer array and displaying them.

Sowohl der Vorgänger als auch der Fortsetzungsaufgabe wird ein Abbruchtoken übergeben.A cancellation token is passed to both the antecedent and the continuation task. Ein System.Timers.Timer Objekt wird verwendet, um einen Timeoutwert von 100 Millisekunden zu definieren.A System.Timers.Timer object is used to define a timeout value of 100 milliseconds. Wenn das Ereignis ausgelöst wird, die CancellationTokenSource.Cancel Methode wird aufgerufen, und das Abbruchtoken, das wird verwendet, um den Abbruch der Aufgaben anzufordern.If the event fires, the CancellationTokenSource.Cancel method is called, and the cancellation token is used to request cancellation of the tasks.

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

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

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

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

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

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

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

Module Example
   Dim ts As CancellationTokenSource

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

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

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

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

In der Regel durch Angeben des ungefähr 100.000 Werts führt dazu, dass das Timeoutintervall abläuft und die Timer.Elapsed Ereignis ausgelöst, und die abbruchanforderung festgelegt werden.Typically, supplying a value of about 100,000 causes the timeout interval to expire and the Timer.Elapsed event to fire, and the cancellation request to be set.

Hinweise

Das zurückgegebene Task wird nicht zur Ausführung geplant werden erst nach Abschluss die aktuelle Aufgabe, ob der Vorgang aufgrund von erfolgreich ausgeführt, Fehler aufgrund eines Ausnahmefehlers oder beenden Sie frühzeitig aufgrund eines Abbruchs abgeschlossen ist.The returned Task will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

Siehe auch

ContinueWith(Action<Task<TResult>,Object>, Object) ContinueWith(Action<Task<TResult>,Object>, Object) ContinueWith(Action<Task<TResult>,Object>, Object) 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.Creates a continuation that is passed state information and that executes when the target Task<TResult> completes.

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

Parameter

continuationAction
Action<Task<TResult>,Object>

Eine Aktion, die beim Abschluss von Task<TResult> ausgeführt werden soll.An action to run when the Task<TResult> completes. Wenn der Delegat ausgeführt wird, werden ihm der abgeschlossene Task und das vom Aufrufer bereitgestellte Zustandsobjekt als Argumente übergeben.When run, the delegate is passed the completed task and the caller-supplied state object as arguments.

state
Object Object Object Object

Ein Objekt, das Daten darstellt, die von der Fortsetzungsaktion verwendet werden sollen.An object representing data to be used by the continuation action.

Gibt zurück

Ein neuer Fortsetzungs-Task.A new continuation Task.

Ausnahmen

Das continuationAction-Argument ist null.The continuationAction argument is null.

Beispiele

Das folgende Beispiel erstellt eine Aufgabe, die eine ganze Zahl zwischen 2 und 20 übergeben wird, und gibt ein Array, das die ersten zehn Exponenten enthält (n1 n10) dieser Zahl.The following example creates a task that is passed an integer between 2 and 20 and returns an array that contains the first ten exponents (from n1 to n10) of that number. Eine Fortsetzungsaufgabe ist dann dafür verantwortlich, die Exponenten.A continuation task is then responsible for displaying the exponents. Es wird übergeben, sowohl der Vorgänger als auch die ursprüngliche Anzahl, deren Exponenten, die die vorangehende Aufgabe generiert.It is passed both the antecedent and the original number whose exponents the antecedent generates.

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

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

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

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

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

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

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

Hinweise

Das zurückgegebene Task wird nicht zur Ausführung geplant werden erst nach Abschluss die aktuelle Aufgabe, ob der Vorgang aufgrund von erfolgreich ausgeführt, Fehler aufgrund eines Ausnahmefehlers oder beenden Sie frühzeitig aufgrund eines Abbruchs abgeschlossen ist.The returned Task will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

Siehe auch

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

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn die Zielaufgabe abgeschlossen wurde.Creates a continuation that executes asynchronously when the target task completes.

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

Parameter

continuationAction
Action<Task<TResult>>

Eine Aktion, die beim Abschluss vom vorhergehenden Task<TResult> ausgeführt werden soll.An action to run when the antecedent Task<TResult> completes. Bei der Ausführung wird dem Delegaten die abgeschlossene Aufgabe als Argument übergeben.When run, the delegate will be passed the completed task as an argument.

Gibt zurück

Eine neue Fortsetzungsaufgabe.A new continuation task.

Ausnahmen

Das continuationAction-Argument lautet null.The continuationAction argument is null.

Beispiele

Das folgende Beispiel erstellt eine Vorgängeraufgabe, die das Sieb des Eratosthenes zum Berechnen von Primzahlen zwischen 1 und vom Benutzer eingegebene Wert verwendet.The following example creates an antecedent task that uses the Sieve of Eratosthenes to calculate the prime numbers between 1 and a value entered by the user. Ein Array ist zum Speichern von Informationen über die Primzahlen verwendet.An array is used to hold information about the prime numbers. Index des Arrays darstellt, die Anzahl und den Wert des Elements angibt, ob diese Zahl zusammengesetzt ist (der Wert ist true) oder vorzubereiten (der Wert ist false).The array index represents the number, and the element's value indicates whether that number is composite (its value is true) or prime (its value is false). Diese Aufgabe wird dann an eine Fortsetzungsaufgabe übergeben, die für die Primzahlen aus einem Ganzzahlen-Array zu extrahieren und zu deren Anzeige zuständig ist.This task is then passed to a continuation task, which is responsible for extracting the prime numbers from the integer array and displaying them.

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

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

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

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

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

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

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

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

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

Hinweise

Das zurückgegebene Task wird nicht zur Ausführung geplant werden erst nach Abschluss die aktuelle Aufgabe, ob der Vorgang abgeschlossen wurde, erfolgreich ausgeführt, Fehler aufgrund einer nicht behandelten Ausnahme oder einem frühen Zeitpunkt aufgrund eines Abbruchs beendet.The returned Task will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting early due to being canceled.

Siehe auch

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

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task<TResult> abgeschlossen wurde.Creates a continuation that executes asynchronously when the target Task<TResult> completes.

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

Parameter

continuationAction
Action<Task<TResult>>

Eine Aktion, die beim Abschluss von Task<TResult> ausgeführt werden soll.An action to run when the Task<TResult> completes. Bei der Ausführung wird dem Delegaten die abgeschlossene Aufgabe als Argument übergeben.When run, the delegate will be passed the completed task as an argument.

scheduler
TaskScheduler TaskScheduler TaskScheduler TaskScheduler

Das TaskScheduler, das der Fortsetzungsaufgabe zugeordnet und für ihre Ausführung verwendet werden soll.The TaskScheduler to associate with the continuation task and to use for its execution.

Gibt zurück

Ein neuer Fortsetzungs-Task.A new continuation Task.

Ausnahmen

Das continuationAction-Argument ist null.The continuationAction argument is null.

- oder --or- Das scheduler-Argument ist null.The scheduler argument is null.

Hinweise

Das zurückgegebene Task wird nicht zur Ausführung geplant werden erst nach Abschluss die aktuelle Aufgabe, ob der Vorgang aufgrund von erfolgreich ausgeführt, Fehler aufgrund eines Ausnahmefehlers oder beenden Sie frühzeitig aufgrund eines Abbruchs abgeschlossen ist.The returned Task will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

Siehe auch

ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler) ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler) 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.Creates a continuation that executes when the target Task<TResult> completes.

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>

Typparameter

TNewResult

Der Typ des von der Fortsetzung generierten Ergebnisses.The type of the result produced by the continuation.

Parameter

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

Eine Funktion, die ausgeführt werden soll, wenn das Task<TResult> abgeschlossen ist.A function to run when the Task<TResult> completes. Bei der Ausführung werden dem Delegaten die abgeschlossene Aufgabe und das vom Aufrufer angegebene Zustandsobjekt als Argumente übergeben.When run, the delegate will be passed the completed task and the caller-supplied state object as arguments.

state
Object Object Object Object

Ein Objekt, das Daten darstellt, die von der Fortsetzungsfunktion verwendet werden sollen.An object representing data to be used by the continuation function.

cancellationToken
CancellationToken CancellationToken CancellationToken CancellationToken

Das CancellationToken, das der neuen Aufgabe zugewiesen wird.The CancellationToken that will be assigned to the new task.

continuationOptions
TaskContinuationOptions TaskContinuationOptions TaskContinuationOptions TaskContinuationOptions

Optionen für die Planung und das Verhalten der Fortsetzung.Options for when the continuation is scheduled and how it behaves. Dazu zählen Kriterien wie OnlyOnCanceled und Ausführungsoptionen wie ExecuteSynchronously.This includes criteria, such as OnlyOnCanceled, as well as execution options, such as ExecuteSynchronously.

scheduler
TaskScheduler TaskScheduler TaskScheduler TaskScheduler

Das TaskScheduler, das der Fortsetzungsaufgabe zugeordnet und für ihre Ausführung verwendet werden soll.The TaskScheduler to associate with the continuation task and to use for its execution.

Gibt zurück

Task<TNewResult>

Ein neuer Fortsetzungs-Task<TResult>.A new continuation Task<TResult>.

Ausnahmen

Das scheduler-Argument ist null.The scheduler argument is null.

Das continuationOptions-Argument gibt einen ungültigen Wert für TaskContinuationOptions an.The continuationOptions argument specifies an invalid value for TaskContinuationOptions.

Das angegebene CancellationToken wurde bereits freigegeben.The provided CancellationToken has already been disposed.

Hinweise

Das zurückgegebene Task<TResult> wird nicht zur Ausführung geplant werden erst nach Abschluss die aktuelle Aufgabe, ob der Vorgang aufgrund von erfolgreich ausgeführt, Fehler aufgrund eines Ausnahmefehlers oder beenden Sie frühzeitig aufgrund eines Abbruchs abgeschlossen ist.The returned Task<TResult> will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

Die continuationFunction, bei der Ausführung sollte Zurückgeben einer Task<TResult>.The continuationFunction, when executed, should return a Task<TResult>. Abschlussstatus des Vorgangs werden an die Rückgabe des Tasks durch Übertragen der Task<TResult>.ContinueWith aufrufen.This task's completion state will be transferred to the task returned from the Task<TResult>.ContinueWith call.

Siehe auch

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

Erstellt eine Fortsetzung, die nach der in continuationOptions angegebenen Bedingung ausgeführt wird.Creates a continuation that executes according the condition specified in continuationOptions.

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>

Typparameter

TNewResult

Der Typ des von der Fortsetzung generierten Ergebnisses.The type of the result produced by the continuation.

Parameter

continuationFunction
Func<Task<TResult>,TNewResult>

Eine Funktion, die entsprechend der in continuationOptions angegebenen Bedingung ausgeführt wird.A function to run according the condition specified in continuationOptions.

Bei der Ausführung wird dem Delegaten diese abgeschlossene Aufgabe als Argument übergeben.When run, the delegate will be passed as an argument this completed task.

cancellationToken
CancellationToken CancellationToken CancellationToken CancellationToken

Das CancellationToken, das der neuen Aufgabe zugewiesen wird.The CancellationToken that will be assigned to the new task.

continuationOptions
TaskContinuationOptions TaskContinuationOptions TaskContinuationOptions TaskContinuationOptions

Optionen für die Planung und das Verhalten der Fortsetzung.Options for when the continuation is scheduled and how it behaves. Dazu zählen Kriterien wie OnlyOnCanceled und Ausführungsoptionen wie ExecuteSynchronously.This includes criteria, such as OnlyOnCanceled, as well as execution options, such as ExecuteSynchronously.

scheduler
TaskScheduler TaskScheduler TaskScheduler TaskScheduler

Das TaskScheduler, das der Fortsetzungsaufgabe zugeordnet und für ihre Ausführung verwendet werden soll.The TaskScheduler to associate with the continuation task and to use for its execution.

Gibt zurück

Task<TNewResult>

Ein neuer Fortsetzungs-Task<TResult>.A new continuation Task<TResult>.

Ausnahmen

Task<TResult> wurde verworfen.The Task<TResult> has been disposed.

- oder --or- Die CancellationTokenSource, die cancellationToken erstellt hat, wurde bereits freigegeben.The CancellationTokenSource that created cancellationToken has already been disposed.

Das continuationFunction-Argument ist null.The continuationFunction argument is null.

- oder --or- Das scheduler-Argument ist null.The scheduler argument is null.

Das continuationOptions-Argument gibt einen ungültigen Wert für TaskContinuationOptions an.The continuationOptions argument specifies an invalid value for TaskContinuationOptions.

Hinweise

Das zurückgegebene Task<TResult> wird nicht zur Ausführung geplant werden erst nach Abschluss die aktuelle Aufgabe, ob der Vorgang aufgrund von erfolgreich ausgeführt, Fehler aufgrund eines Ausnahmefehlers oder beenden Sie frühzeitig aufgrund eines Abbruchs abgeschlossen ist.The returned Task<TResult> will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

Die continuationFunction, bei der Ausführung sollte Zurückgeben einer Task<TResult>.The continuationFunction, when executed, should return a Task<TResult>.

Siehe auch

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

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.Creates a continuation that executes when the target Task<TResult> completes.

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)

Typparameter

TNewResult

Der Typ des von der Fortsetzung generierten Ergebnisses.The type of the result produced by the continuation.

Parameter

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

Eine Funktion, die ausgeführt werden soll, wenn das Task<TResult> abgeschlossen ist.A function to run when the Task<TResult> completes. Bei der Ausführung werden dem Delegaten die abgeschlossene Aufgabe und das vom Aufrufer angegebene Zustandsobjekt als Argumente übergeben.When run, the delegate will be passed the completed task and the caller-supplied state object as arguments.

state
Object Object Object Object

Ein Objekt, das Daten darstellt, die von der Fortsetzungsfunktion verwendet werden sollen.An object representing data to be used by the continuation function.

scheduler
TaskScheduler TaskScheduler TaskScheduler TaskScheduler

Das TaskScheduler, das der Fortsetzungsaufgabe zugeordnet und für ihre Ausführung verwendet werden soll.The TaskScheduler to associate with the continuation task and to use for its execution.

Gibt zurück

Task<TNewResult>

Ein neuer Fortsetzungs-Task<TResult>.A new continuation Task<TResult>.

Ausnahmen

Das scheduler-Argument ist null.The scheduler argument is null.

Hinweise

Das zurückgegebene Task<TResult> wird nicht zur Ausführung geplant werden erst nach Abschluss die aktuelle Aufgabe, ob der Vorgang aufgrund von erfolgreich ausgeführt, Fehler aufgrund eines Ausnahmefehlers oder beenden Sie frühzeitig aufgrund eines Abbruchs abgeschlossen ist.The returned Task<TResult> will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

Siehe auch

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

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.Creates a continuation that executes when the target Task<TResult> completes.

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)

Typparameter

TNewResult

Der Typ des von der Fortsetzung generierten Ergebnisses.The type of the result produced by the continuation.

Parameter

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

Eine Funktion, die ausgeführt werden soll, wenn das Task<TResult> abgeschlossen ist.A function to run when the Task<TResult> completes. Bei der Ausführung werden dem Delegaten die abgeschlossene Aufgabe und das vom Aufrufer angegebene Zustandsobjekt als Argumente übergeben.When run, the delegate will be passed the completed task and the caller-supplied state object as arguments.

state
Object Object Object Object

Ein Objekt, das Daten darstellt, die von der Fortsetzungsfunktion verwendet werden sollen.An object representing data to be used by the continuation function.

continuationOptions
TaskContinuationOptions TaskContinuationOptions TaskContinuationOptions TaskContinuationOptions

Optionen für die Planung und das Verhalten der Fortsetzung.Options for when the continuation is scheduled and how it behaves. Dazu zählen Kriterien wie OnlyOnCanceled und Ausführungsoptionen wie ExecuteSynchronously.This includes criteria, such as OnlyOnCanceled, as well as execution options, such as ExecuteSynchronously.

Gibt zurück

Task<TNewResult>

Ein neuer Fortsetzungs-Task<TResult>.A new continuation Task<TResult>.

Ausnahmen

Das continuationFunction-Argument ist null.The continuationFunction argument is null.

Das continuationOptions-Argument gibt einen ungültigen Wert für TaskContinuationOptions an.The continuationOptions argument specifies an invalid value for TaskContinuationOptions.

Hinweise

Das zurückgegebene Task<TResult> wird nicht zur Ausführung geplant werden erst nach Abschluss die aktuelle Aufgabe, ob der Vorgang aufgrund von erfolgreich ausgeführt, Fehler aufgrund eines Ausnahmefehlers oder beenden Sie frühzeitig aufgrund eines Abbruchs abgeschlossen ist.The returned Task<TResult> will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

Die continuationFunction, bei der Ausführung sollte Zurückgeben einer Task<TResult>.The continuationFunction, when executed, should return a Task<TResult>. Abschlussstatus des Vorgangs wird für die Aufgabe, die vom ContinueWith-Aufruf zurückgegebene übertragen werden.This task's completion state will be transferred to the task returned from the ContinueWith call.

Siehe auch

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

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.Creates a continuation that executes when the target Task<TResult> completes.

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>

Typparameter

TNewResult

Der Typ des von der Fortsetzung generierten Ergebnisses.The type of the result produced by the continuation.

Parameter

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

Eine Funktion, die ausgeführt werden soll, wenn das Task<TResult> abgeschlossen ist.A function to run when the Task<TResult> completes. Bei der Ausführung werden dem Delegaten die abgeschlossene Aufgabe und das vom Aufrufer angegebene Zustandsobjekt als Argumente übergeben.When run, the delegate will be passed the completed task and the caller-supplied state object as arguments.

state
Object Object Object Object

Ein Objekt, das Daten darstellt, die von der Fortsetzungsfunktion verwendet werden sollen.An object representing data to be used by the continuation function.

cancellationToken
CancellationToken CancellationToken CancellationToken CancellationToken

Das CancellationToken, das der neuen Aufgabe zugewiesen wird.The CancellationToken that will be assigned to the new task.

Gibt zurück

Task<TNewResult>

Ein neuer Fortsetzungs-Task<TResult>.A new continuation Task<TResult>.

Ausnahmen

Das continuationFunction-Argument ist null.The continuationFunction argument is null.

Das angegebene CancellationToken wurde bereits freigegeben.The provided CancellationToken has already been disposed.

Hinweise

Das zurückgegebene Task<TResult> wird nicht zur Ausführung geplant werden erst nach Abschluss die aktuelle Aufgabe, ob der Vorgang aufgrund von erfolgreich ausgeführt, Fehler aufgrund eines Ausnahmefehlers oder beenden Sie frühzeitig aufgrund eines Abbruchs abgeschlossen ist.The returned Task<TResult> will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

Siehe auch

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

Erstellt eine Fortsetzung, die nach der in continuationOptions angegebenen Bedingung ausgeführt wird.Creates a continuation that executes according the condition specified in continuationOptions.

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

Typparameter

TNewResult

Der Typ des von der Fortsetzung generierten Ergebnisses.The type of the result produced by the continuation.

Parameter

continuationFunction
Func<Task<TResult>,TNewResult>

Eine Funktion, die entsprechend der in continuationOptions angegebenen Bedingung ausgeführt wird.A function to run according the condition specified in continuationOptions.

Bei der Ausführung wird dem Delegaten die abgeschlossene Aufgabe als Argument übergeben.When run, the delegate will be passed the completed task as an argument.

continuationOptions
TaskContinuationOptions TaskContinuationOptions TaskContinuationOptions TaskContinuationOptions

Optionen für die Planung und das Verhalten der Fortsetzung.Options for when the continuation is scheduled and how it behaves. Dazu zählen Kriterien wie OnlyOnCanceled und Ausführungsoptionen wie ExecuteSynchronously.This includes criteria, such as OnlyOnCanceled, as well as execution options, such as ExecuteSynchronously.

Gibt zurück

Task<TNewResult>

Ein neuer Fortsetzungs-Task<TResult>.A new continuation Task<TResult>.

Ausnahmen

Das continuationFunction-Argument ist null.The continuationFunction argument is null.

Das continuationOptions-Argument gibt einen ungültigen Wert für TaskContinuationOptions an.The continuationOptions argument specifies an invalid value for TaskContinuationOptions.

Hinweise

Das zurückgegebene Task<TResult> wird nicht zur Ausführung geplant werden erst nach Abschluss die aktuelle Aufgabe, ob der Vorgang aufgrund von erfolgreich ausgeführt, Fehler aufgrund eines Ausnahmefehlers oder beenden Sie frühzeitig aufgrund eines Abbruchs abgeschlossen ist.The returned Task<TResult> will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

Die continuationFunction, bei der Ausführung sollte Zurückgeben einer Task<TResult>.The continuationFunction, when executed, should return a Task<TResult>.

Siehe auch

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

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task<TResult> abgeschlossen wurde.Creates a continuation that executes asynchronously when the target Task<TResult> completes.

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>

Typparameter

TNewResult

Der Typ des von der Fortsetzung generierten Ergebnisses.The type of the result produced by the continuation.

Parameter

continuationFunction
Func<Task<TResult>,TNewResult>

Eine Funktion, die ausgeführt werden soll, wenn das Task<TResult> abgeschlossen ist.A function to run when the Task<TResult> completes. Bei der Ausführung wird dem Delegaten die abgeschlossene Aufgabe als Argument übergeben.When run, the delegate will be passed the completed task as an argument.

cancellationToken
CancellationToken CancellationToken CancellationToken CancellationToken

Das CancellationToken, das der neuen Aufgabe zugewiesen wird.The CancellationToken that will be assigned to the new task.

Gibt zurück

Task<TNewResult>

Ein neuer Fortsetzungs-Task<TResult>.A new continuation Task<TResult>.

Ausnahmen

Task<TResult> wurde verworfen.The Task<TResult> has been disposed.

- oder --or- Die CancellationTokenSource, die cancellationToken erstellt hat, wurde bereits freigegeben.The CancellationTokenSource that created cancellationToken has already been disposed.

Das continuationFunction-Argument ist null.The continuationFunction argument is null.

Hinweise

Das zurückgegebene Task<TResult> wird nicht zur Ausführung geplant werden erst nach Abschluss die aktuelle Aufgabe, ob der Vorgang aufgrund von erfolgreich ausgeführt, Fehler aufgrund eines Ausnahmefehlers oder beenden Sie frühzeitig aufgrund eines Abbruchs abgeschlossen ist.The returned Task<TResult> will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

Siehe auch

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

Erstellt eine Fortsetzung, die ausgeführt wird, wenn die Ziel-Task<TResult> abgeschlossen ist.Creates a continuation that executes when the target Task<TResult> completes.

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)

Typparameter

TNewResult

Der Typ des von der Fortsetzung generierten Ergebnisses.The type of the result produced by the continuation.

Parameter

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

Eine Funktion, die ausgeführt werden soll, wenn das Task<TResult> abgeschlossen ist.A function to run when the Task<TResult> completes. Bei der Ausführung werden dem Delegaten die abgeschlossene Aufgabe und das vom Aufrufer angegebene Zustandsobjekt als Argumente übergeben.When run, the delegate will be passed the completed task and the caller-supplied state object as arguments.

state
Object Object Object Object

Ein Objekt, das Daten darstellt, die von der Fortsetzungsfunktion verwendet werden sollen.An object representing data to be used by the continuation function.

Gibt zurück

Task<TNewResult>

Ein neuer Fortsetzungs-Task<TResult>.A new continuation Task<TResult>.

Ausnahmen

Das continuationFunction-Argument ist null.The continuationFunction argument is null.

Beispiele

Im folgende Beispiel wird eine Kette von Fortsetzungsaufgaben erstellt.The following example creates a chain of continuation tasks. Jede Aufgabe stellt die aktuelle Uhrzeit ein DateTime -Objekt, um die Status-Argument, der die ContinueWith(Action<Task,Object>, Object) Methode.Each task provides the current time, a DateTime object, for the state argument of the ContinueWith(Action<Task,Object>, Object) method. Jede DateTime Wert darstellt, die Zeit, zu dem die Aufgabe weiter erstellt wird.Each DateTime value represents the time at which the continue task is created. Jede Aufgabe erzeugt als Ergebnis ein zweites DateTime Wert, der die Zeit darstellt, an dem die Aufgabe abgeschlossen ist.Each task produces as its result a second DateTime value that represents the time at which the task finishes. Nachdem alle Aufgaben abgeschlossen haben, zeigt das Beispiel, das Datum und die Häufigkeit, mit denen jede Fortsetzungsaufgabe gestartet und abgeschlossen wurde.After all tasks finish, the example displays the date and times at which each continuation task starts and finishes.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Hinweise

Das zurückgegebene Task<TResult> wird nicht zur Ausführung geplant werden erst nach Abschluss die aktuelle Aufgabe, ob der Vorgang aufgrund von erfolgreich ausgeführt, Fehler aufgrund eines Ausnahmefehlers oder beenden Sie frühzeitig aufgrund eines Abbruchs abgeschlossen ist.The returned Task<TResult> will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

Siehe auch

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

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task<TResult> abgeschlossen wurde.Creates a continuation that executes asynchronously when the target Task<TResult> completes.

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

Typparameter

TNewResult

Der Typ des von der Fortsetzung generierten Ergebnisses.The type of the result produced by the continuation.

Parameter

continuationFunction
Func<Task<TResult>,TNewResult>

Eine Funktion, die ausgeführt werden soll, wenn das Task<TResult> abgeschlossen ist.A function to run when the Task<TResult> completes. Bei der Ausführung wird dem Delegaten die abgeschlossene Aufgabe als Argument übergeben.When run, the delegate will be passed the completed task as an argument.

Gibt zurück

Task<TNewResult>

Ein neuer Fortsetzungs-Task<TResult>.A new continuation Task<TResult>.

Ausnahmen

Das continuationFunction-Argument ist null.The continuationFunction argument is null.

Hinweise

Das zurückgegebene Task<TResult> wird nicht zur Ausführung geplant werden erst nach Abschluss die aktuelle Aufgabe, ob der Vorgang aufgrund von erfolgreich ausgeführt, Fehler aufgrund eines Ausnahmefehlers oder beenden Sie frühzeitig aufgrund eines Abbruchs abgeschlossen ist.The returned Task<TResult> will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

Siehe auch

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

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task<TResult> abgeschlossen wurde.Creates a continuation that executes asynchronously when the target Task<TResult> completes.

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

Typparameter

TNewResult

Der Typ des von der Fortsetzung generierten Ergebnisses.The type of the result produced by the continuation.

Parameter

continuationFunction
Func<Task<TResult>,TNewResult>

Eine Funktion, die ausgeführt werden soll, wenn das Task<TResult> abgeschlossen ist.A function to run when the Task<TResult> completes. Bei der Ausführung wird dem Delegaten die abgeschlossene Aufgabe als Argument übergeben.When run, the delegate will be passed the completed task as an argument.

scheduler
TaskScheduler TaskScheduler TaskScheduler TaskScheduler

Das TaskScheduler, das der Fortsetzungsaufgabe zugeordnet und für ihre Ausführung verwendet werden soll.The TaskScheduler to associate with the continuation task and to use for its execution.

Gibt zurück

Task<TNewResult>

Ein neuer Fortsetzungs-Task<TResult>.A new continuation Task<TResult>.

Ausnahmen

Das continuationFunction-Argument ist null.The continuationFunction argument is null.

- oder --or- Das scheduler-Argument ist null.The scheduler argument is null.

Hinweise

Das zurückgegebene Task<TResult> wird nicht zur Ausführung geplant werden erst nach Abschluss die aktuelle Aufgabe, ob der Vorgang aufgrund von erfolgreich ausgeführt, Fehler aufgrund eines Ausnahmefehlers oder beenden Sie frühzeitig aufgrund eines Abbruchs abgeschlossen ist.The returned Task<TResult> will not be scheduled for execution until the current task has completed, whether it completes due to running to completion successfully, faulting due to an unhandled exception, or exiting out early due to being canceled.

Siehe auch

Gilt für: