Collapse the table of content
Expand the table of content
Expand Minimize

TaskFactory.ContinueWhenAny Method (Task[], Action(Task))

Creates a continuation Task that will be started upon the completion of any Task in the provided set.

Namespace:  System.Threading.Tasks
Assemblies:   mscorlib (in mscorlib.dll)
  System.Threading.Tasks (in System.Threading.Tasks.dll)

member ContinueWhenAny : 
        tasks:Task[] * 
        continuationAction:Action<Task> -> Task


Type: System.Threading.Tasks.Task[]

The array of tasks from which to continue when one task completes.

Type: System.Action(Task)

The action delegate to execute when one task in the tasks array completes.

Return Value

Type: System.Threading.Tasks.Task
The new continuation Task.


One of the elements in the tasks array has been disposed.


The tasks array is a null reference (Nothing in Visual Basic).


The The continuationAction argument is a null reference (Nothing in Visual Basic).


The tasks array contains a a null reference (Nothing in Visual Basic) value.


The tasks array is empty.

The following example shows how to use ContinueWhenAny and 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: 
    static void Main()
        // Schedule a list of tasks that return integer
        Task<int>[] tasks = new Task<int>[]
				Task<int>.Factory.StartNew(() => 
						Console.WriteLine("Task={0}, Thread={1}, x=5", Task.CurrentId, Thread.CurrentThread.ManagedThreadId);
						return 5;

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

				Task<int>.Factory.StartNew(() => 
						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.
            (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);


.NET Framework

Supported in: 4.6, 4.5, 4

.NET Framework Client Profile

Supported in: 4

.NET for Windows Phone apps

Supported in: Windows Phone 8.1, Windows Phone Silverlight 8.1, Windows Phone Silverlight 8

Portable Class Library

Supported in: Portable Class Library
Was this page helpful?
(1500 characters remaining)
Thank you for your feedback
© 2015 Microsoft