Task.ContinueWith Task.ContinueWith Task.ContinueWith Task.ContinueWith Method

Definition

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

Überlädt

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

Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen sowie ein Abbruchtoken empfängt und ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde.Creates a continuation that receives caller-supplied state information and a cancellation token and that executes when the target Task completes. Die Fortsetzung wird entsprechend einem Satz angegebener Bedingungen ausgeführt und verwendet einen angegebenen Zeitplan.The continuation executes based on a set of specified conditions and uses a specified scheduler.

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

Erstellt eine Fortsetzung, die, sobald die Zielaufgabe abgeschlossen ist, entsprechend den Angaben in TaskContinuationOptions ausgeführt wird.Creates a continuation that executes when the target task competes according to the specified TaskContinuationOptions. Die Fortsetzung empfängt ein Abbruchtoken und verwendet einen angegebenen Zeitplan.The continuation receives a cancellation token and uses a specified scheduler.

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

Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen empfängt, und wird asynchron ausgeführt, wenn der Ziel-Task abgeschlossen ist.Creates a continuation that receives caller-supplied state information and executes asynchronously when the target Task completes. Die Fortsetzung verwendet einen angegebenen Zeitplan.The continuation uses a specified scheduler.

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

Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen empfängt, und wird ausgeführt, wenn der Ziel-Task abgeschlossen ist.Creates a continuation that receives caller-supplied state information and executes when the target Task completes. Die Fortsetzung wird entsprechend einem Satz angegebener Bedingungen ausgeführt.The continuation executes based on a set of specified conditions.

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

Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen sowie ein Abbruchtoken empfängt und asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde.Creates a continuation that receives caller-supplied state information and a cancellation token and that executes asynchronously when the target Task completes.

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

Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen empfängt, und wird ausgeführt, wenn der Ziel-Task abgeschlossen ist.Creates a continuation that receives caller-supplied state information and executes when the target Task completes.

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

Erstellt eine Fortsetzung, die, sobald die Zielaufgabe abgeschlossen ist, entsprechend den Angaben in TaskContinuationOptions ausgeführt wird.Creates a continuation that executes when the target task completes according to the specified TaskContinuationOptions.

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

Erstellt eine Fortsetzung, die ein Abbruchtoken empfängt und asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde.Creates a continuation that receives a cancellation token and executes asynchronously when the target Task completes.

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

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

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

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde.Creates a continuation that executes asynchronously when the target Task completes. Die Fortsetzung verwendet einen angegebenen Zeitplan.The continuation uses a specified scheduler.

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

Erstellt eine Fortsetzung, die entsprechend den angegebenen Aufgabenfortsetzungsoptionen ausgeführt wird, wenn der Ziel-Task abgeschlossen ist.Creates a continuation that executes based on the specified task continuation options when the target Task completes. Die Fortsetzung empfängt vom Aufrufer bereitgestellte Zustandsinformationen.The continuation receives caller-supplied state information.

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

Erstellt eine Fortsetzung, die entsprechend den angegebenen Aufgabenfortsetzungsoptionen ausgeführt wird, wenn der Ziel-Task abgeschlossen ist, und gibt einen Wert zurück.Creates a continuation that executes based on the specified task continuation options when the target Task completes and returns a value. Die Fortsetzung empfängt vom Aufrufer bereitgestellte Zustandsinformationen sowie ein Abbruchtoken und verwendet den angegebenen Zeitplan.The continuation receives caller-supplied state information and a cancellation token and uses the specified scheduler.

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

Erstellt eine Fortsetzung, die entsprechend den angegebenen Fortsetzungsoptionen ausgeführt wird, und gibt einen Wert zurück.Creates a continuation that executes according to the specified continuation options and returns a value. An die Fortsetzung wird ein Abbruchtoken übergeben, und sie verwendet einen angegebenen Zeitplan.The continuation is passed a cancellation token and uses a specified scheduler.

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

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde.Creates a continuation that executes asynchronously when the target Task completes. Die Fortsetzung empfängt vom Aufrufer bereitgestellte Zustandsinformationen und verwendet einen angegebenen Zeitplan.The continuation receives caller-supplied state information and uses a specified scheduler.

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

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde, und gibt einen Wert zurück.Creates a continuation that executes asynchronously when the target Task completes and returns a value. Die Fortsetzung empfängt vom Aufrufer bereitgestellte Zustandsinformationen sowie ein Abbruchtoken.The continuation receives caller-supplied state information and a cancellation token.

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

Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen empfängt, und wird asynchron ausgeführt, wenn der Ziel-Task abgeschlossen ist, und gibt einen Wert zurück.Creates a continuation that receives caller-supplied state information and executes asynchronously when the target Task completes and returns a value.

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

Erstellt eine Fortsetzung, die entsprechend den angegebenen Fortsetzungsoptionen ausgeführt wird, und gibt einen Wert zurück.Creates a continuation that executes according to the specified continuation options and returns a value.

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

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde, und gibt einen Wert zurück.Creates a continuation that executes asynchronously when the target Task completes and returns a value. Die Fortsetzung empfängt ein Abbruchtoken.The continuation receives a cancellation token.

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

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task<TResult> abgeschlossen wurde, und gibt einen Wert zurück.Creates a continuation that executes asynchronously when the target Task<TResult> completes and returns a value.

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

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde, und gibt einen Wert zurück.Creates a continuation that executes asynchronously when the target Task completes and returns a value. Die Fortsetzung verwendet einen angegebenen Zeitplan.The continuation uses a specified scheduler.

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

Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen sowie ein Abbruchtoken empfängt und ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde.Creates a continuation that receives caller-supplied state information and a cancellation token and that executes when the target Task completes. Die Fortsetzung wird entsprechend einem Satz angegebener Bedingungen ausgeführt und verwendet einen angegebenen Zeitplan.The continuation executes based on a set of specified conditions and uses a specified scheduler.

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^, System::Object ^> ^ continuationAction, System::Object ^ state, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskContinuationOptions continuationOptions, System::Threading::Tasks::TaskScheduler ^ scheduler);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object> continuationAction, object state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);
member this.ContinueWith : Action<System.Threading.Tasks.Task, obj> * obj * System.Threading.CancellationToken * System.Threading.Tasks.TaskContinuationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task

Parameter

continuationAction
Action<Task,Object>

Eine Aktion, die beim Abschluss von Task ausgeführt werden soll.An action to run when the Task 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 lautet 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.

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

Erstellt eine Fortsetzung, die, sobald die Zielaufgabe abgeschlossen ist, entsprechend den Angaben in TaskContinuationOptions ausgeführt wird.Creates a continuation that executes when the target task competes according to the specified TaskContinuationOptions. Die Fortsetzung empfängt ein Abbruchtoken und verwendet einen angegebenen Zeitplan.The continuation receives a cancellation token and uses a specified scheduler.

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^> ^ continuationAction, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskContinuationOptions continuationOptions, System::Threading::Tasks::TaskScheduler ^ scheduler);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task> continuationAction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);
member this.ContinueWith : Action<System.Threading.Tasks.Task> * System.Threading.CancellationToken * System.Threading.Tasks.TaskContinuationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task

Parameter

continuationAction
Action<Task>

Eine Aktion, die nach den angegebenen continuationOptions ausgeführt werden soll.An action to run according to the specified 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

Die CancellationTokenSource, die das Token erstellt hat, wurde bereits freigegeben.The CancellationTokenSource that created the token 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.

Beispiele

Folgendes ist ein Beispiel für die Verwendung von ContinueWith für die Arbeit im Hintergrund sowohl für den Benutzer Schnittstelle Threads ausgeführt werden.The following is an example of using ContinueWith to run work both in the background and on the user interface threads.


private void Button1_Click(object sender, EventArgs e)  
{  
   var backgroundScheduler = TaskScheduler.Default;  
   var uiScheduler = TaskScheduler.FromCurrentSynchronizationContext();  
   Task.Factory.StartNew(delegate { DoBackgroundComputation(); },  
                         backgroundScheduler).  
   ContinueWith(delegate { UpdateUI(); }, uiScheduler).  
                ContinueWith(delegate { DoAnotherBackgroundComputation(); },  
                             backgroundScheduler).  
                ContinueWith(delegate { UpdateUIAgain(); }, uiScheduler);  
}  

Private Sub Button1_Click(ByVal sender As System.Object,   
                          ByVal e As System.EventArgs) Handles Button1.Click  
   Dim backgroundScheduler = TaskScheduler.Default  
   Dim uiScheduler = TaskScheduler.FromCurrentSynchronizationContext()  

   Task.Factory.StartNew(Sub()  
                           DoBackgroundComputation()  
                         End Sub, backgroundScheduler).ContinueWith(Sub(t)  
                            UpdateUI()  
                         End Sub, uiScheduler).ContinueWith(Sub(t)  
                            DoAnotherBackgroundComputation()  
                         End Sub, backgroundScheduler).ContinueWith(Sub(t)  
                            UpdateUIAgain()  
                         End Sub, uiScheduler)  
End Sub  

Hinweise

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.

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

Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen empfängt, und wird asynchron ausgeführt, wenn der Ziel-Task abgeschlossen ist.Creates a continuation that receives caller-supplied state information and executes asynchronously when the target Task completes. Die Fortsetzung verwendet einen angegebenen Zeitplan.The continuation uses a specified scheduler.

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

Parameter

continuationAction
Action<Task,Object>

Eine Aktion, die beim Abschluss von Task ausgeführt werden soll.An action to run when the Task 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.

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

Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen empfängt, und wird ausgeführt, wenn der Ziel-Task abgeschlossen ist.Creates a continuation that receives caller-supplied state information and executes when the target Task completes. Die Fortsetzung wird entsprechend einem Satz angegebener Bedingungen ausgeführt.The continuation executes based on a set of specified conditions.

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

Parameter

continuationAction
Action<Task,Object>

Eine Aktion, die beim Abschluss von Task ausgeführt werden soll.An action to run when the Task 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 lautet 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.

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

Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen sowie ein Abbruchtoken empfängt und asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde.Creates a continuation that receives caller-supplied state information and a cancellation token and that executes asynchronously when the target Task completes.

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^, System::Object ^> ^ continuationAction, System::Object ^ state, System::Threading::CancellationToken cancellationToken);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object> continuationAction, object state, System.Threading.CancellationToken cancellationToken);
member this.ContinueWith : Action<System.Threading.Tasks.Task, obj> * obj * System.Threading.CancellationToken -> System.Threading.Tasks.Task

Parameter

continuationAction
Action<Task,Object>

Eine Aktion, die beim Abschluss von Task ausgeführt werden soll.An action to run when the Task 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 lautet 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.

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

Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen empfängt, und wird ausgeführt, wenn der Ziel-Task abgeschlossen ist.Creates a continuation that receives caller-supplied state information and executes when the target Task completes.

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

Parameter

continuationAction
Action<Task,Object>

Eine Aktion, die ausgeführt werden soll, wenn die Aufgabe abgeschlossen wurde.An action to run when the task 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 a 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

Eine neue Fortsetzungsaufgabe.A new continuation task.

Ausnahmen

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

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 eines Ausnahmefehlers oder beenden frühzeitig auf einen Abbruch zurückzuführen.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 cancellation.

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

Erstellt eine Fortsetzung, die, sobald die Zielaufgabe abgeschlossen ist, entsprechend den Angaben in TaskContinuationOptions ausgeführt wird.Creates a continuation that executes when the target task completes according to the specified TaskContinuationOptions.

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

Parameter

continuationAction
Action<Task>

Eine Aktion, die nach den angegebenen continuationOptions ausgeführt werden soll.An action to run according to the specified 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.

Beispiele

Das folgende Beispiel veranschaulicht die Verwendung TaskContinuationOptions um anzugeben, dass eine Fortsetzungsaufgabe synchron ausgeführt werden soll, wenn die vorangehende Aufgabe abgeschlossen ist.The following example demonstrates using TaskContinuationOptions to specify that a continuation task should run synchronously when the antecedent task completes. (Wenn die angegebene Aufgabe bereits, mit der Zeit abgeschlossen wurde ContinueWith aufgerufen wird, die synchrone Fortsetzung ausgeführt wird, auf dem Thread, von ContinueWith.)(If the specified task has already completed by the time ContinueWith is called, the synchronous continuation will run on the thread calling ContinueWith.)


public class TaskCounter  
{  
   private volatile int _count;  

   public void Track(Task t)  
   {  
      if (t == null) throw new ArgumentNullException("t");  
      Interlocked.Increment(ref _count);  
      t.ContinueWith(ct => Interlocked.Decrement(ref _count), TaskContinuationOptions.ExecuteSynchronously);  
   }  

   public int NumberOfActiveTasks { get { return _count; } }  
}  

Public Class TaskCounter  
   Private _count as Integer  

   Public Sub Track(ByVal t as Task)  
      If t is Nothing Then Throw New ArgumentNullException("t")  
      Interlocked.Increment(_count)  
      t.ContinueWith(Sub(ct)  
                        Interlocked.Decrement(_count)  
                     End Sub,  
                     TaskContinuationOptions.ExecuteSynchronously)  
   End Sub  

   Public ReadOnly Property NumberOfActiveTasks As Integer  
      Get  
         Return _count  
      End Get  
   End Property  
End Class  

Hinweise

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.

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

Erstellt eine Fortsetzung, die ein Abbruchtoken empfängt und asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde.Creates a continuation that receives a cancellation token and executes asynchronously when the target Task completes.

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^> ^ continuationAction, System::Threading::CancellationToken cancellationToken);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task> continuationAction, System.Threading.CancellationToken cancellationToken);
member this.ContinueWith : Action<System.Threading.Tasks.Task> * System.Threading.CancellationToken -> System.Threading.Tasks.Task

Parameter

continuationAction
Action<Task>

Eine Aktion, die beim Abschluss von Task ausgeführt werden soll.An action to run when the Task 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 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

Die CancellationTokenSource, die das Token erstellt hat, wurde bereits freigegeben.The CancellationTokenSource that created the token has already been disposed.

Das continuationAction-Argument ist null.The continuationAction 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.

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

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

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

Parameter

continuationAction
Action<Task>

Eine Aktion, die beim Abschluss von Task ausgeführt werden soll.An action to run when the Task 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

Ein neuer Fortsetzungs-Task.A new continuation Task.

Ausnahmen

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

Beispiele

Das folgende Beispiel definiert eine Aufgabe, die ein Array mit 100 zufälligen Date und Time-Werten aufgefüllt wird.The following example defines a task that populates an array with 100 random date and time values. Er verwendet den ContinueWith(Action<Task>) Methode zum Auswählen der frühesten und den neuesten Date-Werten, sobald das Array vollständig aufgefüllt ist.It uses the ContinueWith(Action<Task>) method to select the earliest and the latest date values once the array is fully populated.

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      var firstTask = Task.Factory.StartNew( () => {
                               Random rnd = new Random();
                               DateTime[] dates = new DateTime[100];
                               Byte[] buffer = new Byte[8];
                               int ctr = dates.GetLowerBound(0);
                               while (ctr <= dates.GetUpperBound(0)) {
                                  rnd.NextBytes(buffer);
                                  long ticks = BitConverter.ToInt64(buffer, 0);
                                  if (ticks <= DateTime.MinValue.Ticks | ticks >= DateTime.MaxValue.Ticks)
                                     continue;

                                  dates[ctr] = new DateTime(ticks);
                                  ctr++;
                               }
                               return dates;
                            } ); 
                         
      Task continuationTask = firstTask.ContinueWith( (antecedent) => {
                             DateTime[] dates = antecedent.Result;
                             DateTime earliest = dates[0];
                             DateTime latest = earliest;
                             
                             for (int ctr = dates.GetLowerBound(0) + 1; ctr <= dates.GetUpperBound(0); ctr++) {
                                if (dates[ctr] < earliest) earliest = dates[ctr];
                                if (dates[ctr] > latest) latest = dates[ctr];
                             }
                             Console.WriteLine("Earliest date: {0}", earliest);
                             Console.WriteLine("Latest date: {0}", latest);
                          } );                      
      // Since a console application otherwise terminates, wait for the continuation to complete.
     continuationTask.Wait();
   }
}
// The example displays output like the following:
//       Earliest date: 2/11/0110 12:03:41 PM
//       Latest date: 7/29/9989 2:14:49 PM
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim firstTask = Task.Factory.StartNew( Function()
                               Dim rnd As New Random()
                               Dim dates(99) As Date
                               Dim buffer(7) As Byte
                               Dim ctr As Integer = dates.GetLowerBound(0)
                               Do While ctr <= dates.GetUpperBound(0)
                                  rnd.NextBytes(buffer)
                                  Dim ticks As Long = BitConverter.ToInt64(buffer, 0)
                                  If ticks <= DateTime.MinValue.Ticks Or ticks >= DateTime.MaxValue.Ticks Then Continue Do

                                  dates(ctr) = New Date(ticks)
                                  ctr += 1
                               Loop
                               Return dates
                            End Function )
                         
      Dim continuationTask As Task = firstTask.ContinueWith( Sub(antecedent)
                             Dim dates() As Date = antecedent.Result
                             Dim earliest As Date = dates(0)
                             Dim latest As Date = earliest
                             
                             For ctr As Integer = dates.GetLowerBound(0) + 1 To dates.GetUpperBound(0)
                                If dates(ctr) < earliest Then earliest = dates(ctr)
                                If dates(ctr) > latest Then latest = dates(ctr)
                             Next
                             Console.WriteLine("Earliest date: {0}", earliest)
                             Console.WriteLine("Latest date: {0}", latest)
                          End Sub)                      
      ' Since a console application otherwise terminates, wait for the continuation to complete.
      continuationTask.Wait()
   End Sub
End Module
' The example displays output like the following:
'       Earliest date: 2/11/0110 12:03:41 PM
'       Latest date: 7/29/9989 2:14:49 PM

Da eine Konsolenanwendung beenden kann, bevor die Fortsetzungsaufgabe ausgeführt wird, die Wait() Methode wird aufgerufen, um sicherzustellen, dass die Fortsetzung, die vor dem Ende des Beispiel Ausführung abgeschlossen ist.Because a console application may terminate before the continuation task executes, the Wait() method is called to ensure that the continuation finishes executing before the example ends.

Ein zusätzliches Beispiel finden Sie unter Verketten von Aufgaben mithilfe von Fortsetzungsaufgaben.For an additional example, see Chaining Tasks by Using Continuation Tasks.

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.

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

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde.Creates a continuation that executes asynchronously when the target Task completes. Die Fortsetzung verwendet einen angegebenen Zeitplan.The continuation uses a specified scheduler.

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

Parameter

continuationAction
Action<Task>

Eine Aktion, die beim Abschluss von Task ausgeführt werden soll.An action to run when the Task 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 lautet 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.

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

Erstellt eine Fortsetzung, die entsprechend den angegebenen Aufgabenfortsetzungsoptionen ausgeführt wird, wenn der Ziel-Task abgeschlossen ist.Creates a continuation that executes based on the specified task continuation options when the target Task completes. Die Fortsetzung empfängt vom Aufrufer bereitgestellte Zustandsinformationen.The continuation receives caller-supplied state information.

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

Typparameter

TResult

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

Parameter

continuationFunction
Func<Task,Object,TResult>

Eine Funktion, die ausgeführt werden soll, wenn das Task abgeschlossen ist.A function to run when the Task 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

Ausnahmen

Das continuationFunction-Argument lautet 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 für die Ausführung geplant werden, bis der aktuelle Task abgeschlossen ist.The returned Task<TResult> 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.

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

Erstellt eine Fortsetzung, die entsprechend den angegebenen Aufgabenfortsetzungsoptionen ausgeführt wird, wenn der Ziel-Task abgeschlossen ist, und gibt einen Wert zurück.Creates a continuation that executes based on the specified task continuation options when the target Task completes and returns a value. Die Fortsetzung empfängt vom Aufrufer bereitgestellte Zustandsinformationen sowie ein Abbruchtoken und verwendet den angegebenen Zeitplan.The continuation receives caller-supplied state information and a cancellation token and uses the specified scheduler.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, System::Object ^, TResult> ^ continuationFunction, System::Object ^ state, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskContinuationOptions continuationOptions, System::Threading::Tasks::TaskScheduler ^ scheduler);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object,TResult> continuationFunction, object state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);
member this.ContinueWith : Func<System.Threading.Tasks.Task, obj, 'Result> * obj * System.Threading.CancellationToken * System.Threading.Tasks.TaskContinuationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task<'Result>

Typparameter

TResult

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

Parameter

continuationFunction
Func<Task,Object,TResult>

Eine Funktion, die ausgeführt werden soll, wenn das Task abgeschlossen ist.A function to run when the Task 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 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

Ausnahmen

Das scheduler-Argument lautet 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 für die Ausführung geplant werden, bis der aktuelle Task abgeschlossen ist.The returned Task<TResult> 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.

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

Erstellt eine Fortsetzung, die entsprechend den angegebenen Fortsetzungsoptionen ausgeführt wird, und gibt einen Wert zurück.Creates a continuation that executes according to the specified continuation options and returns a value. An die Fortsetzung wird ein Abbruchtoken übergeben, und sie verwendet einen angegebenen Zeitplan.The continuation is passed a cancellation token and uses a specified scheduler.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, TResult> ^ continuationFunction, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskContinuationOptions continuationOptions, System::Threading::Tasks::TaskScheduler ^ scheduler);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,TResult> continuationFunction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);
member this.ContinueWith : Func<System.Threading.Tasks.Task, 'Result> * System.Threading.CancellationToken * System.Threading.Tasks.TaskContinuationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task<'Result>

Typparameter

TResult

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

Parameter

continuationFunction
Func<Task,TResult>

Eine Funktion, die entsprechend der in continuationOptions angegebenen Bedingung ausgeführt wird.A function to run according to the specified 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

Ausnahmen

Task wurde verworfen.The Task has been disposed.

- oder --or- Die CancellationTokenSource, die das Token erstellt hat, wurde bereits freigegeben.The CancellationTokenSource that created the token 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.

Beispiele

Das folgende Beispiel zeigt, wie Sie die ContinueWith-Methode mit Optionen für die Fortsetzung verwenden:The following example shows how to use the ContinueWith method with continuation options:

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

class ContinuationOptionsDemo
{
    // Demonstrated features:
    //      TaskContinuationOptions
    //		Task.ContinueWith()
    // 		Task.Factory
    //		Task.Wait()
    // Expected results:
    // 		This sample demonstrates branched continuation sequences - Task+Commit or Task+Rollback.
    //      Notice that no if statements are used.
    //		The first sequence is successful - tran1 and commitTran1 are executed. rollbackTran1 is canceled.
    //		The second sequence is unsuccessful - tran2 and rollbackTran2 are executed. tran2 is faulted, and commitTran2 is canceled.
    // Documentation:
    //		http://msdn.microsoft.com/library/system.threading.tasks.taskcontinuationoptions(VS.100).aspx
    static void Main()
    {
        Action success = () => Console.WriteLine("Task={0}, Thread={1}: Begin successful transaction",
                                                Task.CurrentId, Thread.CurrentThread.ManagedThreadId);
        Action failure = () =>
        {
            Console.WriteLine("Task={0}, Thread={1}: Begin transaction and encounter an error",
                                Task.CurrentId, Thread.CurrentThread.ManagedThreadId);
            throw new InvalidOperationException("SIMULATED EXCEPTION");
        };

        Action<Task> commit = (antecendent) => Console.WriteLine("Task={0}, Thread={1}: Commit transaction",
                                                                Task.CurrentId, Thread.CurrentThread.ManagedThreadId);
        Action<Task> rollback = (antecendent) =>
        {
            // "Observe" your antecedent's exception so as to avoid an exception
            // being thrown on the finalizer thread
            var unused = antecendent.Exception;

            Console.WriteLine("Task={0}, Thread={1}: Rollback transaction",
                  Task.CurrentId, Thread.CurrentThread.ManagedThreadId);
        };

        // Successful transaction - Begin + Commit
        Console.WriteLine("Demonstrating a successful transaction");

        // Initial task
        // Treated as "fire-and-forget" -- any exceptions will be cleaned up in rollback continuation
        Task tran1 = Task.Factory.StartNew(success);

        // The following task gets scheduled only if tran1 completes successfully
        var commitTran1 = tran1.ContinueWith(commit, TaskContinuationOptions.OnlyOnRanToCompletion);

        // The following task gets scheduled only if tran1 DOES NOT complete successfully
        var rollbackTran1 = tran1.ContinueWith(rollback, TaskContinuationOptions.NotOnRanToCompletion);

        // For demo purposes, wait for the sample to complete
        commitTran1.Wait();

        // -----------------------------------------------------------------------------------


        // Failed transaction - Begin + exception + Rollback
        Console.WriteLine("\nDemonstrating a failed transaction");

        // Initial task
        // Treated as "fire-and-forget" -- any exceptions will be cleaned up in rollback continuation
        Task tran2 = Task.Factory.StartNew(failure);

        // The following task gets scheduled only if tran2 completes successfully
        var commitTran2 = tran2.ContinueWith(commit, TaskContinuationOptions.OnlyOnRanToCompletion);

        // The following task gets scheduled only if tran2 DOES NOT complete successfully
        var rollbackTran2 = tran2.ContinueWith(rollback, TaskContinuationOptions.NotOnRanToCompletion);

        // For demo purposes, wait for the sample to complete
        rollbackTran2.Wait();
    }

}
Imports System.Threading
Imports System.Threading.Tasks
Module ContuationOptionsDemo
    ' Demonstrated features:
    '   TaskContinuationOptions
    '   Task.ContinueWith()
    '   Task.Factory
    '   Task.Wait()
    ' Expected results:
    '   This sample demonstrates branched continuation sequences - Task+Commit or Task+Rollback.
    '   Notice that no if statements are used.
    '   The first sequence is successful - tran1 and commitTran1 are executed. rollbackTran1 is canceled.
    '   The second sequence is unsuccessful - tran2 and rollbackTran2 are executed. tran2 is faulted, and commitTran2 is canceled.
    ' Documentation:
    '   http://msdn.microsoft.com/library/system.threading.tasks.taskcontinuationoptions(VS.100).aspx
    Private Sub Main()
        Dim success As Action = Sub()
                                    Console.WriteLine("Task={0}, Thread={1}: Begin successful transaction", Task.CurrentId, Thread.CurrentThread.ManagedThreadId)
                                End Sub

        Dim failure As Action = Sub()
                                    Console.WriteLine("Task={0}, Thread={1}: Begin transaction and encounter an error", Task.CurrentId, Thread.CurrentThread.ManagedThreadId)
                                    Throw New InvalidOperationException("SIMULATED EXCEPTION")
                                End Sub

        Dim commit As Action(Of Task) = Sub(antecendent)
                                            Console.WriteLine("Task={0}, Thread={1}: Commit transaction", Task.CurrentId, Thread.CurrentThread.ManagedThreadId)
                                        End Sub

        Dim rollback As Action(Of Task) = Sub(antecendent)
                                              ' "Observe" your antecedent's exception so as to avoid an exception
                                              ' being thrown on the finalizer thread
                                              Dim unused = antecendent.Exception

                                              Console.WriteLine("Task={0}, Thread={1}: Rollback transaction", Task.CurrentId, Thread.CurrentThread.ManagedThreadId)
                                          End Sub

        ' Successful transaction - Begin + Commit
        Console.WriteLine("Demonstrating a successful transaction")

        ' Initial task
        ' Treated as "fire-and-forget" -- any exceptions will be cleaned up in rollback continuation
        Dim tran1 As Task = Task.Factory.StartNew(success)

        ' The following task gets scheduled only if tran1 completes successfully
        Dim commitTran1 = tran1.ContinueWith(commit, TaskContinuationOptions.OnlyOnRanToCompletion)

        ' The following task gets scheduled only if tran1 DOES NOT complete successfully
        Dim rollbackTran1 = tran1.ContinueWith(rollback, TaskContinuationOptions.NotOnRanToCompletion)

        ' For demo purposes, wait for the sample to complete
        commitTran1.Wait()

        ' -----------------------------------------------------------------------------------


        ' Failed transaction - Begin + exception + Rollback 
        Console.WriteLine(vbLf & "Demonstrating a failed transaction")

        ' Initial task
        ' Treated as "fire-and-forget" -- any exceptions will be cleaned up in rollback continuation
        Dim tran2 As Task = Task.Factory.StartNew(failure)

        ' The following task gets scheduled only if tran2 completes successfully
        Dim commitTran2 = tran2.ContinueWith(commit, TaskContinuationOptions.OnlyOnRanToCompletion)

        ' The following task gets scheduled only if tran2 DOES NOT complete successfully
        Dim rollbackTran2 = tran2.ContinueWith(rollback, TaskContinuationOptions.NotOnRanToCompletion)

        ' For demo purposes, wait for the sample to complete
        rollbackTran2.Wait()
    End Sub
End Module

Hinweise

Das zurückgegebene Task<TResult> wird nicht für die Ausführung geplant werden, bis der aktuelle Task abgeschlossen ist.The returned Task<TResult> 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.

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

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde.Creates a continuation that executes asynchronously when the target Task completes. Die Fortsetzung empfängt vom Aufrufer bereitgestellte Zustandsinformationen und verwendet einen angegebenen Zeitplan.The continuation receives caller-supplied state information and uses a specified scheduler.

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

Typparameter

TResult

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

Parameter

continuationFunction
Func<Task,Object,TResult>

Eine Funktion, die ausgeführt werden soll, wenn das Task abgeschlossen ist.A function to run when the Task 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

Ausnahmen

Das scheduler-Argument lautet 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.

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

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde, und gibt einen Wert zurück.Creates a continuation that executes asynchronously when the target Task completes and returns a value. Die Fortsetzung empfängt vom Aufrufer bereitgestellte Zustandsinformationen sowie ein Abbruchtoken.The continuation receives caller-supplied state information and a cancellation token.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, System::Object ^, TResult> ^ continuationFunction, System::Object ^ state, System::Threading::CancellationToken cancellationToken);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object,TResult> continuationFunction, object state, System.Threading.CancellationToken cancellationToken);
member this.ContinueWith : Func<System.Threading.Tasks.Task, obj, 'Result> * obj * System.Threading.CancellationToken -> System.Threading.Tasks.Task<'Result>

Typparameter

TResult

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

Parameter

continuationFunction
Func<Task,Object,TResult>

Eine Funktion, die ausgeführt werden soll, wenn das Task abgeschlossen ist.A function to run when the Task 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 Fortsetzungsaufgabe zugewiesen wird.The CancellationToken that will be assigned to the new continuation task.

Gibt zurück

Ausnahmen

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

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

Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen empfängt, und wird asynchron ausgeführt, wenn der Ziel-Task abgeschlossen ist, und gibt einen Wert zurück.Creates a continuation that receives caller-supplied state information and executes asynchronously when the target Task completes and returns a value.

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

Typparameter

TResult

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

Parameter

continuationFunction
Func<Task,Object,TResult>

Eine Funktion, die ausgeführt werden soll, wenn das Task abgeschlossen ist.A function to run when the Task 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

Ausnahmen

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

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

Erstellt eine Fortsetzung, die entsprechend den angegebenen Fortsetzungsoptionen ausgeführt wird, und gibt einen Wert zurück.Creates a continuation that executes according to the specified continuation options and returns a value.

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

Typparameter

TResult

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

Parameter

continuationFunction
Func<Task,TResult>

Eine Funktion, die entsprechend der in continuationOptions angegebenen Bedingung ausgeführt wird.A function to run according to 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

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 für die Ausführung geplant werden, bis der aktuelle Task abgeschlossen ist.The returned Task<TResult> 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.

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

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde, und gibt einen Wert zurück.Creates a continuation that executes asynchronously when the target Task completes and returns a value. Die Fortsetzung empfängt ein Abbruchtoken.The continuation receives a cancellation token.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, TResult> ^ continuationFunction, System::Threading::CancellationToken cancellationToken);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,TResult> continuationFunction, System.Threading.CancellationToken cancellationToken);
member this.ContinueWith : Func<System.Threading.Tasks.Task, 'Result> * System.Threading.CancellationToken -> System.Threading.Tasks.Task<'Result>

Typparameter

TResult

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

Parameter

continuationFunction
Func<Task,TResult>

Eine Funktion, die ausgeführt werden soll, wenn das Task abgeschlossen ist.A function to run when the Task 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 Fortsetzungsaufgabe zugewiesen wird.The CancellationToken that will be assigned to the new continuation task.

Gibt zurück

Ausnahmen

Task wurde verworfen.The Task has been disposed.

- oder --or- Die CancellationTokenSource, die das Token erstellt hat, wurde bereits freigegeben.The CancellationTokenSource that created the token 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.

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

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task<TResult> abgeschlossen wurde, und gibt einen Wert zurück.Creates a continuation that executes asynchronously when the target Task<TResult> completes and returns a value.

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

Typparameter

TResult

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

Parameter

continuationFunction
Func<Task,TResult>

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

Eine neue Fortsetzungsaufgabe.A new continuation task.

Ausnahmen

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

Beispiele

Das folgende Beispiel zeigt, wie Sie mit der ContinueWith-Methode:The following example shows how to use the ContinueWith method:

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

class ContinuationSimpleDemo
{
    // Demonstrated features:
    // 		Task.Factory
    //		Task.ContinueWith()
    //		Task.Wait()
    // Expected results:
    // 		A sequence of three unrelated tasks is created and executed in this order - alpha, beta, gamma.
    //		A sequence of three related tasks is created - each task negates its argument and passes is to the next task: 5, -5, 5 is printed.
    //		A sequence of three unrelated tasks is created where tasks have different types.
    // Documentation:
    //		http://msdn.microsoft.com/library/system.threading.tasks.taskfactory_members(VS.100).aspx
    static void Main()
    {
        Action<string> action =
            (str) =>
                Console.WriteLine("Task={0}, str={1}, Thread={2}", Task.CurrentId, str, Thread.CurrentThread.ManagedThreadId);

        // Creating a sequence of action tasks (that return no result).
        Console.WriteLine("Creating a sequence of action tasks (that return no result)");
        Task.Factory.StartNew(() => action("alpha"))
            .ContinueWith(antecendent => action("beta"))        // Antecedent data is ignored
            .ContinueWith(antecendent => action("gamma"))
            .Wait();


        Func<int, int> negate =
            (n) =>
            {
                Console.WriteLine("Task={0}, n={1}, -n={2}, Thread={3}", Task.CurrentId, n, -n, Thread.CurrentThread.ManagedThreadId);
                return -n;
            };

        // Creating a sequence of function tasks where each continuation uses the result from its antecendent
        Console.WriteLine("\nCreating a sequence of function tasks where each continuation uses the result from its antecendent");
        Task<int>.Factory.StartNew(() => negate(5))
            .ContinueWith(antecendent => negate(antecendent.Result))		// Antecedent result feeds into continuation
            .ContinueWith(antecendent => negate(antecendent.Result))
            .Wait();


        // Creating a sequence of tasks where you can mix and match the types
        Console.WriteLine("\nCreating a sequence of tasks where you can mix and match the types");
        Task<int>.Factory.StartNew(() => negate(6))
            .ContinueWith(antecendent => action("x"))
            .ContinueWith(antecendent => negate(7))
            .Wait();
    }
}
Imports System.Threading
Imports System.Threading.Tasks

Module ContinuationDemo

    ' Demonstrated features:
    '   Task.Factory
    '   Task.ContinueWith()
    '   Task.Wait()
    ' Expected results:
    '   A sequence of three unrelated tasks is created and executed in this order - alpha, beta, gamma.
    '   A sequence of three related tasks is created - each task negates its argument and passes is to the next task: 5, -5, 5 is printed.
    '   A sequence of three unrelated tasks is created where tasks have different types.
    ' Documentation:
    '   http://msdn.microsoft.com/library/system.threading.tasks.taskfactory_members(VS.100).aspx
    Sub Main()
        Dim action As Action(Of String) = Sub(str) Console.WriteLine("Task={0}, str={1}, Thread={2}", Task.CurrentId, str, Thread.CurrentThread.ManagedThreadId)

        ' Creating a sequence of action tasks (that return no result).
        Console.WriteLine("Creating a sequence of action tasks (that return no result)")
        ' Continuations ignore antecedent data
        Task.Factory.StartNew(Sub() action("alpha")).ContinueWith(Sub(antecendent) action("beta")).ContinueWith(Sub(antecendent) action("gamma")).Wait()


        Dim negate As Func(Of Integer, Integer) = Function(n)
                                                      Console.WriteLine("Task={0}, n={1}, -n={2}, Thread={3}", Task.CurrentId, n, -n, Thread.CurrentThread.ManagedThreadId)
                                                      Return -n
                                                  End Function

        ' Creating a sequence of function tasks where each continuation uses the result from its antecendent
        Console.WriteLine(vbLf & "Creating a sequence of function tasks where each continuation uses the result from its antecendent")
        Task(Of Integer).Factory.StartNew(Function() negate(5)).ContinueWith(Function(antecendent) negate(antecendent.Result)).ContinueWith(Function(antecendent) negate(antecendent.Result)).Wait()


        ' Creating a sequence of tasks where you can mix and match the types
        Console.WriteLine(vbLf & "Creating a sequence of tasks where you can mix and match the types")
        Task(Of Integer).Factory.StartNew(Function() negate(6)).ContinueWith(Sub(antecendent) action("x")).ContinueWith(Function(antecendent) negate(7)).Wait()
    End Sub
End Module

Hinweise

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.

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

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde, und gibt einen Wert zurück.Creates a continuation that executes asynchronously when the target Task completes and returns a value. Die Fortsetzung verwendet einen angegebenen Zeitplan.The continuation uses a specified scheduler.

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

Typparameter

TResult

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

Parameter

continuationFunction
Func<Task,TResult>

Eine Funktion, die ausgeführt werden soll, wenn das Task abgeschlossen ist.A function to run when the Task 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

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.

Gilt für: