| CoreTaskExtensionsThenTSource Method (TaskTSource, FuncTaskTSource, Task, Boolean) | 
             Execute a continuation task when a task completes. The continuation
             task is synchronously created by a continuation function, and then unwrapped to
             form the result of this method. The supportsErrors
             parameter specifies whether the continuation is executed if the antecedent task is faulted.
             
 
Namespace: Rackspace.ThreadingAssembly: Rackspace.Threading (in Rackspace.Threading.dll) Version: 1.1.0.0
 Syntax
Syntax
                                                                                            
                                                                                              
                                                                                                                  
                                                                                                                          public static Task Then<TSource>(
	this Task<TSource> task,
	Func<Task<TSource>, Task> continuationFunction,
	bool supportsErrors
)
 
                                                                                                                                                        <ExtensionAttribute>
Public Shared Function Then(Of TSource) ( 
	task As Task(Of TSource),
	continuationFunction As Func(Of Task(Of TSource), Task),
	supportsErrors As Boolean
) As Task
 
                                                                                                                                                                                                        public:
[ExtensionAttribute]
generic<typename TSource>
static Task^ Then(
	Task<TSource>^ task, 
	Func<Task<TSource>^, Task^>^ continuationFunction, 
	bool supportsErrors
)
 
                                                                                                                                                                                                                                          [<ExtensionAttribute>]
static member Then : 
        task : Task<'TSource> * 
        continuationFunction : Func<Task<'TSource>, Task> * 
        supportsErrors : bool -> Task 
   Parameters
                                                                                                                                                                                                                                                                              - task
- Type: System.Threading.TasksTaskTSource
 The antecedent task.
- continuationFunction
- Type: SystemFuncTaskTSource, Task
 The continuation function to execute when task completes. The continuation function returns a Task which provides the final result of the continuation.
- supportsErrors
- Type: SystemBoolean
 if the continuationFunction properly handles a faulted antecedent task; otherwise, .
Type Parameters
                                                                                                                                                                                                                                                                                                                                                                            - TSource
- The type of the result produced by the antecedent TaskTResult.
Return Value
Type: 
TaskA 
Task representing the unwrapped asynchronous operation.
Usage Note
In Visual Basic and C#, you can call this method as an instance method on any object of type 
TaskTSource. When you use instance method syntax to call this method, omit the first parameter. For more information, see 
Extension Methods (Visual Basic) or 
Extension Methods (C# Programming Guide).
  Exceptions
Exceptions Remarks
Remarks
             This code implements support for the following construct without requiring the use of 
/
.
            
             
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    try
{
    TSource source = await task.ConfigureAwait(false);
}
catch
{
    if (!supportsErrors)
        throw;
}
await continuationFunction(task).ConfigureAwait(false);   If the antecedent task is canceled, or faulted with supportsErrors
             set to , the status
             of the antecedent is directly applied to the task returned by this method; it is
             not wrapped in an additional AggregateException.
             
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |  Notes to Callers | 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | Since the continuationFunction is executed synchronously, this
             method should only be used for lightweight continuation functions. This restriction
             applies only to continuationFunction itself, not to the
             Task returned by it. | 
  Version Information
Version Information
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
.NET for Windows Store apps
Supported in: Windows 8
.NET Framework
Supported in: 4.5, 4.0, 3.5
Portable Class Library
Supported in: Portable Class Library (Legacy), Portable Class Library
Rackspace Threading Library
Supported in: 1.1, 1.0
 See Also
See Also