TaskFactory.ContinueWhenAny 方法

定义

命名空间:

System.Threading.Tasks

程序集:

netstandard.dll, System.Runtime.dll

创建一个延续，该延续 Task 将在完成提供集中的任何任务后启动。

重载

名称	说明
ContinueWhenAny(Task[], Action<Task>, TaskContinuationOptions)	创建一个延续，该延续 Task 将在完成提供集中的任何任务后启动。
ContinueWhenAny(Task[], Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler)	创建一个延续，该延续 Task 将在完成提供集中的任何任务后启动。
ContinueWhenAny(Task[], Action<Task>)	创建一个延续，该延续 Task 将在完成提供集中的任何任务后启动。
ContinueWhenAny(Task[], Action<Task>, CancellationToken)	创建一个延续，该延续 Task 将在完成提供集中的任何任务后启动。
ContinueWhenAny<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>, TaskContinuationOptions)	创建一个延续，该延续 Task<TResult> 将在完成提供集中的任何任务后启动。
ContinueWhenAny<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>)	创建一个延续，该延续 Task<TResult> 将在完成提供集中的任何任务后启动。
ContinueWhenAny<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>, CancellationToken)	创建一个延续，该延续 Task<TResult> 将在完成提供集中的任何任务后启动。
ContinueWhenAny<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	创建一个延续，该延续 Task<TResult> 将在完成提供集中的任何任务后启动。
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>>)	创建一个延续，该延续 Task 将在完成提供集中的任何任务后启动。
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>>, CancellationToken)	创建一个延续，该延续 Task 将在完成提供集中的任何任务后启动。
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>>, TaskContinuationOptions)	创建一个延续，该延续 Task 将在完成提供集中的任何任务后启动。
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>>, CancellationToken, TaskContinuationOptions, TaskScheduler)	创建一个延续，该延续 Task 将在完成提供集中的任何任务后启动。
ContinueWhenAny<TResult>(Task[], Func<Task,TResult>)	创建一个延续，该延续 Task<TResult> 将在完成提供集中的任何任务后启动。
ContinueWhenAny<TResult>(Task[], Func<Task,TResult>, CancellationToken)	创建一个延续，该延续 Task<TResult> 将在完成提供集中的任何任务后启动。
ContinueWhenAny<TResult>(Task[], Func<Task,TResult>, TaskContinuationOptions)	创建一个延续，该延续 Task<TResult> 将在完成提供集中的任何任务后启动。
ContinueWhenAny<TResult>(Task[], Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	创建一个延续，该延续 Task<TResult> 将在完成提供集中的任何任务后启动。

ContinueWhenAny(Task[], Action<Task>, TaskContinuationOptions)

Source:

TaskFactory.cs

创建一个延续，该延续 Task 将在完成提供集中的任何任务后启动。

public:
 System::Threading::Tasks::Task ^ ContinueWhenAny(cli::array <System::Threading::Tasks::Task ^> ^ tasks, Action<System::Threading::Tasks::Task ^> ^ continuationAction, System::Threading::Tasks::TaskContinuationOptions continuationOptions);

public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, Action<System.Threading.Tasks.Task> continuationAction, System.Threading.Tasks.TaskContinuationOptions continuationOptions);

member this.ContinueWhenAny : System.Threading.Tasks.Task[] * Action<System.Threading.Tasks.Task> * System.Threading.Tasks.TaskContinuationOptions -> System.Threading.Tasks.Task

Public Function ContinueWhenAny (tasks As Task(), continuationAction As Action(Of Task), continuationOptions As TaskContinuationOptions) As Task

参数

tasks

Task[]

一个任务完成时要从中继续的任务数组。

continuationAction

Action<Task>

当数组中的 tasks 一个任务完成时要执行的操作委托。

continuationOptions

TaskContinuationOptions

TaskContinuationOptions控制所创建延续Task行为的值。

返回

Task

新的延续 Task。

例外

ObjectDisposedException

数组中的 tasks 一个元素已被释放。

ArgumentNullException

数组 tasks 为 null.

-或-

continuationAction 是 null。

ArgumentOutOfRangeException

continuationOptions 指定无效的 TaskContinuationOptions 值。

ArgumentException

数组 tasks 包含一个 null 值。

-或-

数组 tasks 为空。

注解

NotOn* 和 OnlyOn* TaskContinuationOptions（约束 TaskStatus 将执行延续）是非法的 ContinueWhenAny。

另请参阅

• 任务并行库 (TPL)
• 通过链式任务实现任务的延续
• 任务取消

ContinueWhenAny(Task[], Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Source:

TaskFactory.cs

创建一个延续，该延续 Task 将在完成提供集中的任何任务后启动。

public:
 System::Threading::Tasks::Task ^ ContinueWhenAny(cli::array <System::Threading::Tasks::Task ^> ^ tasks, 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 ContinueWhenAny(System.Threading.Tasks.Task[] tasks, Action<System.Threading.Tasks.Task> continuationAction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);

member this.ContinueWhenAny : System.Threading.Tasks.Task[] * Action<System.Threading.Tasks.Task> * System.Threading.CancellationToken * System.Threading.Tasks.TaskContinuationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task

Public Function ContinueWhenAny (tasks As Task(), continuationAction As Action(Of Task), cancellationToken As CancellationToken, continuationOptions As TaskContinuationOptions, scheduler As TaskScheduler) As Task

参数

tasks

Task[]

一个任务完成时要从中继续的任务数组。

continuationAction

Action<Task>

当数组中的 tasks 一个任务完成时要执行的操作委托。

cancellationToken

CancellationToken

将 CancellationToken 分配给新的延续任务。

continuationOptions

TaskContinuationOptions

TaskContinuationOptions控制所创建延续Task行为的值。

scheduler

TaskScheduler

用于 TaskScheduler 计划创建的延续 Task。

返回

Task

新的延续 Task。

例外

ArgumentNullException

数组 tasks 为 null.

-或-

continuationAction 是 null。

-或-

scheduler 是 null。

ArgumentException

数组 tasks 包含一个 null 值。

-或-

数组 tasks 为空。

ArgumentOutOfRangeException

continuationOptions 指定无效的 TaskContinuationOptions 值。

ObjectDisposedException

已释放所提供的 CancellationToken 内容。

注解

NotOn* 和 OnlyOn* TaskContinuationOptions（约束 TaskStatus 将执行延续）是非法的 ContinueWhenAny。

另请参阅

• 任务并行库 (TPL)
• 通过链式任务实现任务的延续
• 任务取消

ContinueWhenAny(Task[], Action<Task>)

Source:

TaskFactory.cs

创建一个延续，该延续 Task 将在完成提供集中的任何任务后启动。

public:
 System::Threading::Tasks::Task ^ ContinueWhenAny(cli::array <System::Threading::Tasks::Task ^> ^ tasks, Action<System::Threading::Tasks::Task ^> ^ continuationAction);

public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, Action<System.Threading.Tasks.Task> continuationAction);

member this.ContinueWhenAny : System.Threading.Tasks.Task[] * Action<System.Threading.Tasks.Task> -> System.Threading.Tasks.Task

Public Function ContinueWhenAny (tasks As Task(), continuationAction As Action(Of Task)) As Task

参数

tasks

Task[]

一个任务完成时要从中继续的任务数组。

continuationAction

Action<Task>

当数组中的 tasks 一个任务完成时要执行的操作委托。

返回

Task

新的延续 Task。

例外

ObjectDisposedException

数组中的 tasks 一个元素已被释放。

ArgumentNullException

数组 tasks 为 null.

-或-

参数 continuationAction 为 null.

ArgumentException

数组 tasks 包含一个 null 值。

-或-

数组 tasks 为空。

示例

以下示例演示如何使用 ContinueWhenAny 和 ContinueWhenAll：

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

class ContinueWhenMultiDemo
{
    // Demonstrated features:
    // 		Task.Factory
    //		TaskFactory.ContinueWhenAll()
    //		TaskFactory.ContinueWhenAny()
    //		Task.Wait()
    // Expected results:
    // 		Three tasks are created in parallel. 
    //		Each task for a different period of time prints a number and returns it.
    //      A ContinueWhenAny() task indicates the first of the three tasks to complete.
    //      A ContinueWhenAll() task sums up the results of the three tasks and prints out the total.
    // Documentation:
    //		http://msdn.microsoft.com/library/system.threading.tasks.taskfactory_members(VS.100).aspx
    static void Main()
    {
        // Schedule a list of tasks that return integer
        Task<int>[] tasks = new Task<int>[]
            {
                Task<int>.Factory.StartNew(() => 
                    {
                        Thread.Sleep(500);
                        Console.WriteLine("Task={0}, Thread={1}, x=5", Task.CurrentId, Thread.CurrentThread.ManagedThreadId);
                        return 5;
                    }),

                Task<int>.Factory.StartNew(() => 
                    {
                        Thread.Sleep(10);
                        Console.WriteLine("Task={0}, Thread={1}, x=3", Task.CurrentId, Thread.CurrentThread.ManagedThreadId);
                        return 3;
                    }),

                Task<int>.Factory.StartNew(() => 
                    {
                        Thread.Sleep(200);
                        Console.WriteLine("Task={0}, Thread={1}, x=2", Task.CurrentId, Thread.CurrentThread.ManagedThreadId);
                        return 2;
                    })
            };

        // Schedule a continuation to indicate the result of the first task to complete
        Task.Factory.ContinueWhenAny(tasks, winner =>
        {
            // You would expect winning result = 3 on multi-core systems, because you expect
            // tasks[1] to finish first.
            Console.WriteLine("Task={0}, Thread={1} (ContinueWhenAny): Winning result = {2}", Task.CurrentId, Thread.CurrentThread.ManagedThreadId, winner.Result);
        });

        // Schedule a continuation that sums up the results of all tasks, then wait on it.
        // The list of antecendent tasks is passed as an argument by the runtime.
        Task.Factory.ContinueWhenAll(tasks,
            (antecendents) =>
            {
                int sum = 0;
                foreach (Task<int> task in antecendents)
                {
                    sum += task.Result;
                }

                Console.WriteLine("Task={0}, Thread={1}, (ContinueWhenAll): Total={2} (expected 10)", Task.CurrentId, Thread.CurrentThread.ManagedThreadId, sum);
            })
            .Wait();
    }
}

Imports System.Threading
Imports System.Threading.Tasks

Module ContinuationWhenMulti
    ' Demonstrated features:
    '   Task.Factory
    '   TaskFactory.ContinueWhenAll()
    '   TaskFactory.ContinueWhenAny()
    '   Task.Wait()
    ' Expected results:
    '   Three tasks are created in parallel. 
    '   Each task for a different period of time prints a number and returns it.
    '   A ContinueWhenAny() task indicates the first of the three tasks to complete.
    '   A ContinueWhenAll() task sums up the results of the three tasks and prints out the total.
    ' Documentation:
    '   http://msdn.microsoft.com/library/system.threading.tasks.taskfactory_members(VS.100).aspx
    Sub Main()
        ' Schedule a list of tasks that return integer
        Dim tasks As Task(Of Integer)() = New Task(Of Integer)() {
            Task(Of Integer).Factory.StartNew(Function()
                                                  Thread.Sleep(500)
                                                  Console.WriteLine("Task={0}, Thread={1}, x=5", Task.CurrentId, Thread.CurrentThread.ManagedThreadId)
                                                  Return 5
                                              End Function),
            Task(Of Integer).Factory.StartNew(Function()
                                                  Thread.Sleep(10)
                                                  Console.WriteLine("Task={0}, Thread={1}, x=3", Task.CurrentId, Thread.CurrentThread.ManagedThreadId)
                                                  Return 3
                                              End Function),
            Task(Of Integer).Factory.StartNew(Function()
                                                  Thread.Sleep(200)
                                                  Console.WriteLine("Task={0}, Thread={1}, x=2", Task.CurrentId, Thread.CurrentThread.ManagedThreadId)
                                                  Return 2
                                              End Function)}


        ' Schedule a continuation to indicate the result of the first task to complete
        Task.Factory.ContinueWhenAny(tasks, Sub(winner)
                                                ' You would expect winning result = 3 on multi-core systems, because you expect
                                                ' tasks[1] to finish first.
                                                Console.WriteLine("Task={0}, Thread={1} (ContinueWhenAny): Winning result = {2}", Task.CurrentId, Thread.CurrentThread.ManagedThreadId, winner.Result)
                                            End Sub)


        ' Schedule a continuation that sums up the results of all tasks, then wait on it.
        ' The list of antecendent tasks is passed as an argument by the runtime.
        Task.Factory.ContinueWhenAll(tasks, Sub(antecendents)
                                                Dim sum As Integer = 0
                                                For Each task__1 As Task(Of Integer) In antecendents
                                                    sum += task__1.Result
                                                Next
                                                Console.WriteLine("Task={0}, Thread={1}, (ContinueWhenAll): Total={2} (expected 10)", Task.CurrentId, Thread.CurrentThread.ManagedThreadId, sum)
                                            End Sub).Wait()
    End Sub
End Module

另请参阅

• 任务并行库 (TPL)
• 通过链式任务实现任务的延续
• 任务取消

ContinueWhenAny(Task[], Action<Task>, CancellationToken)

Source:

TaskFactory.cs

创建一个延续，该延续 Task 将在完成提供集中的任何任务后启动。

public:
 System::Threading::Tasks::Task ^ ContinueWhenAny(cli::array <System::Threading::Tasks::Task ^> ^ tasks, Action<System::Threading::Tasks::Task ^> ^ continuationAction, System::Threading::CancellationToken cancellationToken);

public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, Action<System.Threading.Tasks.Task> continuationAction, System.Threading.CancellationToken cancellationToken);

member this.ContinueWhenAny : System.Threading.Tasks.Task[] * Action<System.Threading.Tasks.Task> * System.Threading.CancellationToken -> System.Threading.Tasks.Task

Public Function ContinueWhenAny (tasks As Task(), continuationAction As Action(Of Task), cancellationToken As CancellationToken) As Task

参数

tasks

Task[]

一个任务完成时要从中继续的任务数组。

continuationAction

Action<Task>

当数组中的 tasks 一个任务完成时要执行的操作委托。

cancellationToken

CancellationToken

将 CancellationToken 分配给新的延续任务。

返回

Task

新的延续 Task。

例外

ObjectDisposedException

数组中的 tasks 一个元素已被释放。

-或-

cancellationToken 已释放。

ArgumentNullException

数组 tasks 为 null.

-或-

参数 continuationAction 为 null.

ArgumentException

数组 tasks 包含一个 null 值。

-或-

数组 tasks 为空。

另请参阅

• 任务并行库 (TPL)
• 通过链式任务实现任务的延续
• 任务取消

ContinueWhenAny<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>, TaskContinuationOptions)

Source:

TaskFactory.cs

创建一个延续，该延续 Task<TResult> 将在完成提供集中的任何任务后启动。

public:
generic <typename TAntecedentResult, typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWhenAny(cli::array <System::Threading::Tasks::Task<TAntecedentResult> ^> ^ tasks, Func<System::Threading::Tasks::Task<TAntecedentResult> ^, TResult> ^ continuationFunction, System::Threading::Tasks::TaskContinuationOptions continuationOptions);

public System.Threading.Tasks.Task<TResult> ContinueWhenAny<TAntecedentResult,TResult>(System.Threading.Tasks.Task<TAntecedentResult>[] tasks, Func<System.Threading.Tasks.Task<TAntecedentResult>,TResult> continuationFunction, System.Threading.Tasks.TaskContinuationOptions continuationOptions);

member this.ContinueWhenAny : System.Threading.Tasks.Task<'AntecedentResult>[] * Func<System.Threading.Tasks.Task<'AntecedentResult>, 'Result> * System.Threading.Tasks.TaskContinuationOptions -> System.Threading.Tasks.Task<'Result>

Public Function ContinueWhenAny(Of TAntecedentResult, TResult) (tasks As Task(Of TAntecedentResult)(), continuationFunction As Func(Of Task(Of TAntecedentResult), TResult), continuationOptions As TaskContinuationOptions) As Task(Of TResult)

类型参数

TAntecedentResult

前 tasks者的结果的类型。

TResult

委托返回 continuationFunction 的结果的类型，以及与创建的 Task<TResult>关联。

参数

tasks

Task<TAntecedentResult>[]

一个任务完成时要从中继续的任务数组。

continuationFunction

Func<Task<TAntecedentResult>,TResult>

当数组中的 tasks 一个任务完成时，要异步执行的函数委托。

continuationOptions

TaskContinuationOptions

TaskContinuationOptions控制所创建延续Task<TResult>行为的值。

返回

Task<TResult>

新的延续 Task<TResult>。

例外

ObjectDisposedException

数组中的 tasks 一个元素已被释放。

ArgumentNullException

数组 tasks 为 null.

-或-

continuationFunction 是 null。

ArgumentOutOfRangeException

continuationOptions 指定无效的 TaskContinuationOptions 值。

ArgumentException

数组 tasks 包含 null 值。

-或-

数组 tasks 为空。

注解

NotOn* 和 OnlyOn* TaskContinuationOptions（约束 TaskStatus 将执行延续）是非法的 ContinueWhenAny。

另请参阅

• 任务并行库 (TPL)
• 通过链式任务实现任务的延续
• 任务取消

ContinueWhenAny<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>)

Source:

TaskFactory.cs

创建一个延续，该延续 Task<TResult> 将在完成提供集中的任何任务后启动。

public:
generic <typename TAntecedentResult, typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWhenAny(cli::array <System::Threading::Tasks::Task<TAntecedentResult> ^> ^ tasks, Func<System::Threading::Tasks::Task<TAntecedentResult> ^, TResult> ^ continuationFunction);

public System.Threading.Tasks.Task<TResult> ContinueWhenAny<TAntecedentResult,TResult>(System.Threading.Tasks.Task<TAntecedentResult>[] tasks, Func<System.Threading.Tasks.Task<TAntecedentResult>,TResult> continuationFunction);

member this.ContinueWhenAny : System.Threading.Tasks.Task<'AntecedentResult>[] * Func<System.Threading.Tasks.Task<'AntecedentResult>, 'Result> -> System.Threading.Tasks.Task<'Result>

Public Function ContinueWhenAny(Of TAntecedentResult, TResult) (tasks As Task(Of TAntecedentResult)(), continuationFunction As Func(Of Task(Of TAntecedentResult), TResult)) As Task(Of TResult)

类型参数

TAntecedentResult

前 tasks者的结果的类型。

TResult

委托返回 continuationFunction 的结果的类型，以及与创建的 Task<TResult>关联。

参数

tasks

Task<TAntecedentResult>[]

一个任务完成时要从中继续的任务数组。

continuationFunction

Func<Task<TAntecedentResult>,TResult>

当数组中的 tasks 一个任务完成时，要异步执行的函数委托。

返回

Task<TResult>

新的延续 Task<TResult>。

例外

ObjectDisposedException

数组中的 tasks 一个元素已被释放。

ArgumentNullException

数组 tasks 为 null.

-或-

continuationFunction 是 null。

ArgumentException

数组 tasks 包含 null 值。

-或-

数组 tasks 为空。

另请参阅

• 任务并行库 (TPL)
• 通过链式任务实现任务的延续
• 任务取消

ContinueWhenAny<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>, CancellationToken)

Source:

TaskFactory.cs

创建一个延续，该延续 Task<TResult> 将在完成提供集中的任何任务后启动。

public:
generic <typename TAntecedentResult, typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWhenAny(cli::array <System::Threading::Tasks::Task<TAntecedentResult> ^> ^ tasks, Func<System::Threading::Tasks::Task<TAntecedentResult> ^, TResult> ^ continuationFunction, System::Threading::CancellationToken cancellationToken);

public System.Threading.Tasks.Task<TResult> ContinueWhenAny<TAntecedentResult,TResult>(System.Threading.Tasks.Task<TAntecedentResult>[] tasks, Func<System.Threading.Tasks.Task<TAntecedentResult>,TResult> continuationFunction, System.Threading.CancellationToken cancellationToken);

member this.ContinueWhenAny : System.Threading.Tasks.Task<'AntecedentResult>[] * Func<System.Threading.Tasks.Task<'AntecedentResult>, 'Result> * System.Threading.CancellationToken -> System.Threading.Tasks.Task<'Result>

Public Function ContinueWhenAny(Of TAntecedentResult, TResult) (tasks As Task(Of TAntecedentResult)(), continuationFunction As Func(Of Task(Of TAntecedentResult), TResult), cancellationToken As CancellationToken) As Task(Of TResult)

类型参数

TAntecedentResult

前 tasks者的结果的类型。

TResult

委托返回 continuationFunction 的结果的类型，以及与创建的 Task<TResult>关联。

参数

tasks

Task<TAntecedentResult>[]

一个任务完成时要从中继续的任务数组。

continuationFunction

Func<Task<TAntecedentResult>,TResult>

当数组中的 tasks 一个任务完成时，要异步执行的函数委托。

cancellationToken

CancellationToken

将 CancellationToken 分配给新的延续任务。

返回

Task<TResult>

新的延续 Task<TResult>。

例外

ObjectDisposedException

数组中的 tasks 一个元素已被释放。

-或-

已释放所提供的 CancellationToken 内容。

ArgumentNullException

数组 tasks 为 null.

-或-

continuationFunction 是 null。

ArgumentException

数组 tasks 包含一个 null 值。

-或-

数组 tasks 为空。

另请参阅

• 任务并行库 (TPL)
• 通过链式任务实现任务的延续
• 任务取消

ContinueWhenAny<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Source:

TaskFactory.cs

创建一个延续，该延续 Task<TResult> 将在完成提供集中的任何任务后启动。

public:
generic <typename TAntecedentResult, typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWhenAny(cli::array <System::Threading::Tasks::Task<TAntecedentResult> ^> ^ tasks, Func<System::Threading::Tasks::Task<TAntecedentResult> ^, TResult> ^ continuationFunction, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskContinuationOptions continuationOptions, System::Threading::Tasks::TaskScheduler ^ scheduler);

public System.Threading.Tasks.Task<TResult> ContinueWhenAny<TAntecedentResult,TResult>(System.Threading.Tasks.Task<TAntecedentResult>[] tasks, Func<System.Threading.Tasks.Task<TAntecedentResult>,TResult> continuationFunction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);

member this.ContinueWhenAny : System.Threading.Tasks.Task<'AntecedentResult>[] * Func<System.Threading.Tasks.Task<'AntecedentResult>, 'Result> * System.Threading.CancellationToken * System.Threading.Tasks.TaskContinuationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task<'Result>

Public Function ContinueWhenAny(Of TAntecedentResult, TResult) (tasks As Task(Of TAntecedentResult)(), continuationFunction As Func(Of Task(Of TAntecedentResult), TResult), cancellationToken As CancellationToken, continuationOptions As TaskContinuationOptions, scheduler As TaskScheduler) As Task(Of TResult)

类型参数

TAntecedentResult

前 tasks者的结果的类型。

TResult

委托返回 continuationFunction 的结果的类型，以及与创建的 Task<TResult>关联。

参数

tasks

Task<TAntecedentResult>[]

一个任务完成时要从中继续的任务数组。

continuationFunction

Func<Task<TAntecedentResult>,TResult>

当数组中的 tasks 一个任务完成时，要异步执行的函数委托。

cancellationToken

CancellationToken

将 CancellationToken 分配给新的延续任务。

continuationOptions

TaskContinuationOptions

TaskContinuationOptions控制所创建延续Task<TResult>行为的值。

scheduler

TaskScheduler

用于 TaskScheduler 计划创建的延续 Task<TResult>。

返回

Task<TResult>

新的延续 Task<TResult>。

例外

ArgumentNullException

数组 tasks 为 null.

-或-

continuationFunction 是 null。

-或-

scheduler 是 null。

ArgumentException

数组 tasks 包含 null 值。

-或-

数组 tasks 为空。

ArgumentOutOfRangeException

continuationOptions 指定无效的 TaskContinuationOptions 值。

ObjectDisposedException

已释放所提供的 CancellationToken 内容。

注解

NotOn* 和 OnlyOn* TaskContinuationOptions（约束 TaskStatus 将执行延续）是非法的 ContinueWhenAny。

另请参阅

• 任务并行库 (TPL)
• 通过链式任务实现任务的延续
• 任务取消

ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>>)

Source:

TaskFactory.cs

创建一个延续，该延续 Task 将在完成提供集中的任何任务后启动。

public:
generic <typename TAntecedentResult>
 System::Threading::Tasks::Task ^ ContinueWhenAny(cli::array <System::Threading::Tasks::Task<TAntecedentResult> ^> ^ tasks, Action<System::Threading::Tasks::Task<TAntecedentResult> ^> ^ continuationAction);

public System.Threading.Tasks.Task ContinueWhenAny<TAntecedentResult>(System.Threading.Tasks.Task<TAntecedentResult>[] tasks, Action<System.Threading.Tasks.Task<TAntecedentResult>> continuationAction);

member this.ContinueWhenAny : System.Threading.Tasks.Task<'AntecedentResult>[] * Action<System.Threading.Tasks.Task<'AntecedentResult>> -> System.Threading.Tasks.Task

Public Function ContinueWhenAny(Of TAntecedentResult) (tasks As Task(Of TAntecedentResult)(), continuationAction As Action(Of Task(Of TAntecedentResult))) As Task

类型参数

TAntecedentResult

前 tasks者的结果的类型。

参数

tasks

Task<TAntecedentResult>[]

一个任务完成时要从中继续的任务数组。

continuationAction

Action<Task<TAntecedentResult>>

当数组中的 tasks 一个任务完成时要执行的操作委托。

返回

Task

新的延续 Task。

例外

ObjectDisposedException

数组中的 tasks 一个元素已被释放。

ArgumentNullException

数组 tasks 为 null.

-或-

continuationAction 是 null。

ArgumentException

数组 tasks 包含一个 null 值。

-或-

数组 tasks 为空。

另请参阅

• 任务并行库 (TPL)
• 通过链式任务实现任务的延续
• 任务取消

ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>>, CancellationToken)

Source:

TaskFactory.cs

创建一个延续，该延续 Task 将在完成提供集中的任何任务后启动。

public:
generic <typename TAntecedentResult>
 System::Threading::Tasks::Task ^ ContinueWhenAny(cli::array <System::Threading::Tasks::Task<TAntecedentResult> ^> ^ tasks, Action<System::Threading::Tasks::Task<TAntecedentResult> ^> ^ continuationAction, System::Threading::CancellationToken cancellationToken);

public System.Threading.Tasks.Task ContinueWhenAny<TAntecedentResult>(System.Threading.Tasks.Task<TAntecedentResult>[] tasks, Action<System.Threading.Tasks.Task<TAntecedentResult>> continuationAction, System.Threading.CancellationToken cancellationToken);

member this.ContinueWhenAny : System.Threading.Tasks.Task<'AntecedentResult>[] * Action<System.Threading.Tasks.Task<'AntecedentResult>> * System.Threading.CancellationToken -> System.Threading.Tasks.Task

Public Function ContinueWhenAny(Of TAntecedentResult) (tasks As Task(Of TAntecedentResult)(), continuationAction As Action(Of Task(Of TAntecedentResult)), cancellationToken As CancellationToken) As Task

类型参数

TAntecedentResult

前 tasks者的结果的类型。

参数

tasks

Task<TAntecedentResult>[]

一个任务完成时要从中继续的任务数组。

continuationAction

Action<Task<TAntecedentResult>>

当数组中的 tasks 一个任务完成时要执行的操作委托。

cancellationToken

CancellationToken

将 CancellationToken 分配给新的延续任务。

返回

Task

新的延续 Task。

例外

ObjectDisposedException

数组中的 tasks 一个元素已被释放。

-或-

已释放所提供的 CancellationToken 内容。

ArgumentNullException

数组 tasks 为 null.

-或-

continuationAction 是 null。

ArgumentException

数组 tasks 包含 null 值。

-或-

数组 tasks 为空。

另请参阅

• 任务并行库 (TPL)
• 通过链式任务实现任务的延续
• 任务取消

ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>>, TaskContinuationOptions)

Source:

TaskFactory.cs

创建一个延续，该延续 Task 将在完成提供集中的任何任务后启动。

public:
generic <typename TAntecedentResult>
 System::Threading::Tasks::Task ^ ContinueWhenAny(cli::array <System::Threading::Tasks::Task<TAntecedentResult> ^> ^ tasks, Action<System::Threading::Tasks::Task<TAntecedentResult> ^> ^ continuationAction, System::Threading::Tasks::TaskContinuationOptions continuationOptions);

public System.Threading.Tasks.Task ContinueWhenAny<TAntecedentResult>(System.Threading.Tasks.Task<TAntecedentResult>[] tasks, Action<System.Threading.Tasks.Task<TAntecedentResult>> continuationAction, System.Threading.Tasks.TaskContinuationOptions continuationOptions);

member this.ContinueWhenAny : System.Threading.Tasks.Task<'AntecedentResult>[] * Action<System.Threading.Tasks.Task<'AntecedentResult>> * System.Threading.Tasks.TaskContinuationOptions -> System.Threading.Tasks.Task

Public Function ContinueWhenAny(Of TAntecedentResult) (tasks As Task(Of TAntecedentResult)(), continuationAction As Action(Of Task(Of TAntecedentResult)), continuationOptions As TaskContinuationOptions) As Task

类型参数

TAntecedentResult

前 tasks者的结果的类型。

参数

tasks

Task<TAntecedentResult>[]

一个任务完成时要从中继续的任务数组。

continuationAction

Action<Task<TAntecedentResult>>

当数组中的 tasks 一个任务完成时要执行的操作委托。

continuationOptions

TaskContinuationOptions

TaskContinuationOptions控制所创建延续Task行为的值。

返回

Task

新的延续 Task。

例外

ObjectDisposedException

数组中的 tasks 一个元素已被释放。

ArgumentNullException

数组 tasks 为 null.

-或-

continuationAction 是 null。

ArgumentOutOfRangeException

continuationOptions 指定无效的 TaskContinuationOptions 值。

ArgumentException

数组 tasks 包含 null 值。

-或-

数组 tasks 为空。

注解

NotOn* 和 OnlyOn* TaskContinuationOptions（约束 TaskStatus 将执行延续）是非法的 ContinueWhenAny。

另请参阅

• 任务并行库 (TPL)
• 通过链式任务实现任务的延续
• 任务取消

ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Source:

TaskFactory.cs

创建一个延续，该延续 Task 将在完成提供集中的任何任务后启动。

public:
generic <typename TAntecedentResult>
 System::Threading::Tasks::Task ^ ContinueWhenAny(cli::array <System::Threading::Tasks::Task<TAntecedentResult> ^> ^ tasks, Action<System::Threading::Tasks::Task<TAntecedentResult> ^> ^ continuationAction, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskContinuationOptions continuationOptions, System::Threading::Tasks::TaskScheduler ^ scheduler);

public System.Threading.Tasks.Task ContinueWhenAny<TAntecedentResult>(System.Threading.Tasks.Task<TAntecedentResult>[] tasks, Action<System.Threading.Tasks.Task<TAntecedentResult>> continuationAction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);

member this.ContinueWhenAny : System.Threading.Tasks.Task<'AntecedentResult>[] * Action<System.Threading.Tasks.Task<'AntecedentResult>> * System.Threading.CancellationToken * System.Threading.Tasks.TaskContinuationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task

Public Function ContinueWhenAny(Of TAntecedentResult) (tasks As Task(Of TAntecedentResult)(), continuationAction As Action(Of Task(Of TAntecedentResult)), cancellationToken As CancellationToken, continuationOptions As TaskContinuationOptions, scheduler As TaskScheduler) As Task

类型参数

TAntecedentResult

前 tasks者的结果的类型。

参数

tasks

Task<TAntecedentResult>[]

一个任务完成时要从中继续的任务数组。

continuationAction

Action<Task<TAntecedentResult>>

当数组中的 tasks 一个任务完成时要执行的操作委托。

cancellationToken

CancellationToken

将 CancellationToken 分配给新的延续任务。

continuationOptions

TaskContinuationOptions

TaskContinuationOptions控制所创建延续Task行为的值。

scheduler

TaskScheduler

用于 TaskScheduler 计划创建的延续 Task<TResult>。

返回

Task

新的延续 Task。

例外

ArgumentNullException

数组 tasks 为 null.

-或-

continuationAction 是 null。

-或-

paramref name=“scheduler” /> is null.

ArgumentException

数组 tasks 包含一个 null 值。

-或-

数组 tasks 为空。

ArgumentOutOfRangeException

continuationOptions 指定无效 TaskContinuationOptions 值。

ObjectDisposedException

已释放所提供的 CancellationToken 内容。

注解

NotOn* 和 OnlyOn* TaskContinuationOptions（约束 TaskStatus 将执行延续）是非法的 ContinueWhenAny。

另请参阅

• 任务并行库 (TPL)
• 通过链式任务实现任务的延续
• 任务取消

ContinueWhenAny<TResult>(Task[], Func<Task,TResult>)

Source:

TaskFactory.cs

创建一个延续，该延续 Task<TResult> 将在完成提供集中的任何任务后启动。

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWhenAny(cli::array <System::Threading::Tasks::Task ^> ^ tasks, Func<System::Threading::Tasks::Task ^, TResult> ^ continuationFunction);

public System.Threading.Tasks.Task<TResult> ContinueWhenAny<TResult>(System.Threading.Tasks.Task[] tasks, Func<System.Threading.Tasks.Task,TResult> continuationFunction);

member this.ContinueWhenAny : System.Threading.Tasks.Task[] * Func<System.Threading.Tasks.Task, 'Result> -> System.Threading.Tasks.Task<'Result>

Public Function ContinueWhenAny(Of TResult) (tasks As Task(), continuationFunction As Func(Of Task, TResult)) As Task(Of TResult)

类型参数

TResult

委托返回 continuationFunction 的结果的类型，以及与创建的 Task<TResult>关联。

参数

tasks

Task[]

一个任务完成时要从中继续的任务数组。

continuationFunction

Func<Task,TResult>

当数组中的 tasks 一个任务完成时，要异步执行的函数委托。

返回

Task<TResult>

新的延续 Task<TResult>。

例外

ObjectDisposedException

数组中的 tasks 一个元素已被释放。

ArgumentNullException

数组 tasks 为 null.

-或-

continuationFunction 是 null。

ArgumentException

数组 tasks 包含 null 值。

-或-

数组 tasks 为空。

另请参阅

• 任务并行库 (TPL)
• 通过链式任务实现任务的延续
• 任务取消

ContinueWhenAny<TResult>(Task[], Func<Task,TResult>, CancellationToken)

Source:

TaskFactory.cs

创建一个延续，该延续 Task<TResult> 将在完成提供集中的任何任务后启动。

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWhenAny(cli::array <System::Threading::Tasks::Task ^> ^ tasks, Func<System::Threading::Tasks::Task ^, TResult> ^ continuationFunction, System::Threading::CancellationToken cancellationToken);

public System.Threading.Tasks.Task<TResult> ContinueWhenAny<TResult>(System.Threading.Tasks.Task[] tasks, Func<System.Threading.Tasks.Task,TResult> continuationFunction, System.Threading.CancellationToken cancellationToken);

member this.ContinueWhenAny : System.Threading.Tasks.Task[] * Func<System.Threading.Tasks.Task, 'Result> * System.Threading.CancellationToken -> System.Threading.Tasks.Task<'Result>

Public Function ContinueWhenAny(Of TResult) (tasks As Task(), continuationFunction As Func(Of Task, TResult), cancellationToken As CancellationToken) As Task(Of TResult)

类型参数

TResult

委托返回 continuationFunction 的结果的类型，以及与创建的 Task<TResult>关联。

参数

tasks

Task[]

一个任务完成时要从中继续的任务数组。

continuationFunction

Func<Task,TResult>

当数组中的 tasks 一个任务完成时，要异步执行的函数委托。

cancellationToken

CancellationToken

将 CancellationToken 分配给新的延续任务。

返回

Task<TResult>

新的延续 Task<TResult>。

例外

ObjectDisposedException

数组中的 tasks 一个元素已被释放。

-或-

已释放所提供的 CancellationToken 内容。

ArgumentNullException

数组 tasks 为 null.

-或-

continuationFunction 是 null。

ArgumentException

数组 tasks 包含一个 null 值。

-或-

数组 tasks 为空。

另请参阅

• 任务并行库 (TPL)
• 通过链式任务实现任务的延续
• 任务取消

ContinueWhenAny<TResult>(Task[], Func<Task,TResult>, TaskContinuationOptions)

Source:

TaskFactory.cs

创建一个延续，该延续 Task<TResult> 将在完成提供集中的任何任务后启动。

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWhenAny(cli::array <System::Threading::Tasks::Task ^> ^ tasks, Func<System::Threading::Tasks::Task ^, TResult> ^ continuationFunction, System::Threading::Tasks::TaskContinuationOptions continuationOptions);

public System.Threading.Tasks.Task<TResult> ContinueWhenAny<TResult>(System.Threading.Tasks.Task[] tasks, Func<System.Threading.Tasks.Task,TResult> continuationFunction, System.Threading.Tasks.TaskContinuationOptions continuationOptions);

member this.ContinueWhenAny : System.Threading.Tasks.Task[] * Func<System.Threading.Tasks.Task, 'Result> * System.Threading.Tasks.TaskContinuationOptions -> System.Threading.Tasks.Task<'Result>

Public Function ContinueWhenAny(Of TResult) (tasks As Task(), continuationFunction As Func(Of Task, TResult), continuationOptions As TaskContinuationOptions) As Task(Of TResult)

类型参数

TResult

委托返回 continuationFunction 的结果的类型，以及与创建的 Task<TResult>关联。

参数

tasks

Task[]

一个任务完成时要从中继续的任务数组。

continuationFunction

Func<Task,TResult>

当数组中的 tasks 一个任务完成时，要异步执行的函数委托。

continuationOptions

TaskContinuationOptions

TaskContinuationOptions控制所创建延续Task<TResult>行为的值。

返回

Task<TResult>

新的延续 Task<TResult>。

例外

ObjectDisposedException

数组中的 tasks 一个元素已被释放。

ArgumentNullException

数组 tasks 为 null.

-或-

continuationFunction 是 null。

ArgumentOutOfRangeException

continuationOptions 指定无效的 TaskContinuationOptions 值。

ArgumentException

数组 tasks 包含一个 null 值。

-或-

数组 tasks 为空。

注解

NotOn* 和 OnlyOn* TaskContinuationOptions（约束 TaskStatus 将执行延续）是非法的 ContinueWhenAny。

另请参阅

• 任务并行库 (TPL)
• 通过链式任务实现任务的延续
• 任务取消

ContinueWhenAny<TResult>(Task[], Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Source:

TaskFactory.cs

创建一个延续，该延续 Task<TResult> 将在完成提供集中的任何任务后启动。

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWhenAny(cli::array <System::Threading::Tasks::Task ^> ^ tasks, 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> ContinueWhenAny<TResult>(System.Threading.Tasks.Task[] tasks, Func<System.Threading.Tasks.Task,TResult> continuationFunction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);

member this.ContinueWhenAny : System.Threading.Tasks.Task[] * Func<System.Threading.Tasks.Task, 'Result> * System.Threading.CancellationToken * System.Threading.Tasks.TaskContinuationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task<'Result>

Public Function ContinueWhenAny(Of TResult) (tasks As Task(), continuationFunction As Func(Of Task, TResult), cancellationToken As CancellationToken, continuationOptions As TaskContinuationOptions, scheduler As TaskScheduler) As Task(Of TResult)

类型参数

TResult

委托返回 continuationFunction 的结果的类型，以及与创建的 Task<TResult>关联。

参数

tasks

Task[]

一个任务完成时要从中继续的任务数组。

continuationFunction

Func<Task,TResult>

当数组中的 tasks 一个任务完成时，要异步执行的函数委托。

cancellationToken

CancellationToken

将 CancellationToken 分配给新的延续任务。

continuationOptions

TaskContinuationOptions

TaskContinuationOptions控制所创建延续Task<TResult>行为的值。

scheduler

TaskScheduler

用于 TaskScheduler 计划创建的延续 Task<TResult>。

返回

Task<TResult>

新的延续 Task<TResult>。

例外

ArgumentNullException

数组 tasks 为 null.

-或-

continuationFunction 是 null。

-或-

scheduler 是 null。

ArgumentException

数组 tasks 包含一个 null 值。

-或-

数组 tasks 为空。

ArgumentOutOfRangeException

continuationOptions 指定无效的 TaskContinuationOptions 值。

ObjectDisposedException

已释放所提供的 CancellationToken 内容。

注解

NotOn* 和 OnlyOn* TaskContinuationOptions（约束 TaskStatus 将执行延续）是非法的 ContinueWhenAny。

另请参阅

• 任务并行库 (TPL)
• 通过链式任务实现任务的延续
• 任务取消