TaskFactory Class

Reference

Definition

Namespace:: System.Threading.Tasks

Assembly:: System.Threading.Tasks.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Source:: TaskFactory.cs

Source:: TaskFactory.cs

Source:: TaskFactory.cs

Important

Some information relates to prerelease product that may be substantially modified before it’s released. Microsoft makes no warranties, express or implied, with respect to the information provided here.

Provides support for creating and scheduling Task objects.

public ref class TaskFactory

public class TaskFactory

type TaskFactory = class

Public Class TaskFactory

Inheritance: Object
TaskFactory

Examples

The following example uses the static Factory property to make two calls to the TaskFactory.StartNew method. The first populates an array with the names of files in the user's MyDocuments directory, while the second populates an array with the names of subdirectories of the user's MyDocuments directory. It then calls the TaskFactory.ContinueWhenAll(Task[], Action<Task[]>) method, which displays information about the number of files and directories in the two arrays after the first two tasks have completed execution.

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

public class Example
{
   public static void Main()
   {
      Task[] tasks = new Task[2];
      String[] files = null;
      String[] dirs = null;
      String docsDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);

      tasks[0] = Task.Factory.StartNew( () => files = Directory.GetFiles(docsDirectory));
      tasks[1] = Task.Factory.StartNew( () => dirs = Directory.GetDirectories(docsDirectory));

      Task.Factory.ContinueWhenAll(tasks, completedTasks => {
                                             Console.WriteLine("{0} contains: ", docsDirectory);
                                             Console.WriteLine("   {0} subdirectories", dirs.Length);
                                             Console.WriteLine("   {0} files", files.Length);
                                          } );
   }
}
// The example displays output like the following:
//       C:\Users\<username>\Documents contains:
//          24 subdirectories
//          16 files

Imports System.IO
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim tasks(1) As Task
      Dim files() As String = Nothing
      Dim dirs() As String = Nothing
      Dim docsDirectory As String = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments)
      
      tasks(0) = Task.Factory.StartNew( Sub()
                                           files = Directory.GetFiles(docsDirectory)
                                        End Sub )
      tasks(1) = Task.Factory.StartNew( Sub()
                                           dirs = Directory.GetDirectories(docsDirectory)
                                        End Sub )
      Task.Factory.ContinueWhenAll(tasks, Sub(completedTasks)
                                             Console.WriteLine("{0} contains: ", docsDirectory)
                                             Console.WriteLine("   {0} subdirectories", dirs.Length)
                                             Console.WriteLine("   {0} files", files.Length)
                                          End Sub)
   End Sub
End Module
' The example displays output like the following:
'       C:\Users\<username>\Documents contains:
'          24 subdirectories
'          16 files

Remarks

.NET provides two factories for creating and scheduling tasks:

The TaskFactory class, which creates Task and Task<TResult> objects. You can call the overloads of this method to create and execute a task that requires non-default arguments.

Warning

Starting with .NET Framework 4.5, the Task.Run method provides the easiest way to create a task with default configuration values and start it immediately.
The TaskFactory<TResult> class, which creates Task<TResult> objects.

The TaskFactory class allows you to do the following:

Create a task and start it immediately by calling the StartNew method.

Warning

Starting with .NET Framework 4.5, the Task.Run method provides the easiest way to create a task with default configuration values and start it immediately.
Create a task that starts when any one of the tasks in an array has completed by calling the ContinueWhenAny method.
Create a task that starts when all the tasks in an array have completed by calling the ContinueWhenAll method.

The static Task<TResult>.Factory property returns a default TaskFactory<TResult> object. You can also call one of the TaskFactory class constructors to configure the Task objects that the TaskFactory class creates. The following example configures a new TaskFactory object to create tasks that have a specified cancellation token, task creation options, continuation options, and a customized task scheduler.

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

class Example
{
   static CancellationTokenSource cts = new CancellationTokenSource();

   static TaskFactory factory = new TaskFactory(
      cts.Token,
      TaskCreationOptions.PreferFairness,
      TaskContinuationOptions.ExecuteSynchronously,
      new CustomScheduler());

   static void Main()
   {
      var t2 = factory.StartNew(() => DoWork());
      cts.Dispose();
   }

   static void DoWork() {/*...*/ }
}

Imports System.Collections.Generic
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim cts As New CancellationTokenSource()
      Dim factory As New TaskFactory(cts.Token,
                                     TaskCreationOptions.PreferFairness,
                                     TaskContinuationOptions.ExecuteSynchronously,
                                     New CustomScheduler())

      Dim t2 = factory.StartNew(Sub() DoWork())
      cts.Dispose()
   End Sub

   Sub DoWork()
      ' ...
   End Sub
End Module

In most cases, you do not have to instantiate a new TaskFactory instance. Instead, you can use the Task.Factory property, which returns a factory object that uses default values. You can then call its methods to start new tasks or define task continuations. For an illustration, see the example.

Constructors

TaskFactory()	Initializes a TaskFactory instance with the default configuration.
TaskFactory(CancellationToken, TaskCreationOptions, TaskContinuationOptions, TaskScheduler)	Initializes a TaskFactory instance with the specified configuration.
TaskFactory(CancellationToken)	Initializes a TaskFactory instance with the specified configuration.
TaskFactory(TaskCreationOptions, TaskContinuationOptions)	Initializes a TaskFactory instance with the specified configuration.
TaskFactory(TaskScheduler)	Initializes a TaskFactory instance with the specified configuration.

Properties

CancellationToken	Gets the default cancellation token for this task factory.
ContinuationOptions	Gets the default task continuation options for this task factory.
CreationOptions	Gets the default task creation options for this task factory.
Scheduler	Gets the default task scheduler for this task factory.

Methods

ContinueWhenAll(Task[], Action<Task[]>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Creates a continuation task that starts when a set of specified tasks has completed.
ContinueWhenAll(Task[], Action<Task[]>, CancellationToken)	Creates a continuation task that starts when a set of specified tasks has completed.
ContinueWhenAll(Task[], Action<Task[]>, TaskContinuationOptions)	Creates a continuation task that starts when a set of specified tasks has completed.
ContinueWhenAll(Task[], Action<Task[]>)	Creates a continuation task that starts when a set of specified tasks has completed.
ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Creates a continuation task that starts when a set of specified tasks has completed.
ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken)	Creates a continuation task that starts when a set of specified tasks has completed.
ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, TaskContinuationOptions)	Creates a continuation task that starts when a set of specified tasks has completed.
ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>)	Creates a continuation task that starts when a set of specified tasks has completed.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Creates a continuation task that starts when a set of specified tasks has completed.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>, CancellationToken)	Creates a continuation task that starts when a set of specified tasks has completed.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>, TaskContinuationOptions)	Creates a continuation task that starts when a set of specified tasks has completed.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>)	Creates a continuation task that starts when a set of specified tasks has completed.
ContinueWhenAll<TResult>(Task[], Func<Task[],TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Creates a continuation task that starts when a set of specified tasks has completed.
ContinueWhenAll<TResult>(Task[], Func<Task[],TResult>, CancellationToken)	Creates a continuation task that starts when a set of specified tasks has completed.
ContinueWhenAll<TResult>(Task[], Func<Task[],TResult>, TaskContinuationOptions)	Creates a continuation task that starts when a set of specified tasks has completed.
ContinueWhenAll<TResult>(Task[], Func<Task[],TResult>)	Creates a continuation task that starts when a set of specified tasks has completed.
ContinueWhenAny(Task[], Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Creates a continuation Task that will be started upon the completion of any Task in the provided set.
ContinueWhenAny(Task[], Action<Task>, CancellationToken)	Creates a continuation Task that will be started upon the completion of any Task in the provided set.
ContinueWhenAny(Task[], Action<Task>, TaskContinuationOptions)	Creates a continuation Task that will be started upon the completion of any Task in the provided set.
ContinueWhenAny(Task[], Action<Task>)	Creates a continuation Task that will be started upon the completion of any Task in the provided set.
ContinueWhenAny<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Creates a continuation Task<TResult> that will be started upon the completion of any Task in the provided set.
ContinueWhenAny<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>, CancellationToken)	Creates a continuation Task<TResult> that will be started upon the completion of any Task in the provided set.
ContinueWhenAny<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>, TaskContinuationOptions)	Creates a continuation Task<TResult> that will be started upon the completion of any Task in the provided set.
ContinueWhenAny<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>)	Creates a continuation Task<TResult> that will be started upon the completion of any Task in the provided set.
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Creates a continuation Task that will be started upon the completion of any Task in the provided set.
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>>, CancellationToken)	Creates a continuation Task that will be started upon the completion of any Task in the provided set.
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>>, TaskContinuationOptions)	Creates a continuation Task that will be started upon the completion of any Task in the provided set.
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>>)	Creates a continuation Task that will be started upon the completion of any Task in the provided set.
ContinueWhenAny<TResult>(Task[], Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Creates a continuation Task<TResult> that will be started upon the completion of any Task in the provided set.
ContinueWhenAny<TResult>(Task[], Func<Task,TResult>, CancellationToken)	Creates a continuation Task<TResult> that will be started upon the completion of any Task in the provided set.
ContinueWhenAny<TResult>(Task[], Func<Task,TResult>, TaskContinuationOptions)	Creates a continuation Task<TResult> that will be started upon the completion of any Task in the provided set.
ContinueWhenAny<TResult>(Task[], Func<Task,TResult>)	Creates a continuation Task<TResult> that will be started upon the completion of any Task in the provided set.
Equals(Object)	Determines whether the specified object is equal to the current object. (Inherited from Object)
FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object, TaskCreationOptions)	Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.
FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object)	Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.
FromAsync(IAsyncResult, Action<IAsyncResult>, TaskCreationOptions, TaskScheduler)	Creates a Task that executes an end method action when a specified IAsyncResult completes.
FromAsync(IAsyncResult, Action<IAsyncResult>, TaskCreationOptions)	Creates a Task that executes an end method action when a specified IAsyncResult completes.
FromAsync(IAsyncResult, Action<IAsyncResult>)	Creates a Task that executes an end method action when a specified IAsyncResult completes.
FromAsync<TArg1,TArg2,TArg3,TResult>(Func<TArg1,TArg2,TArg3,AsyncCallback, Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, TArg2, TArg3, Object, TaskCreationOptions)	Creates a Task<TResult> that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.
FromAsync<TArg1,TArg2,TArg3,TResult>(Func<TArg1,TArg2,TArg3,AsyncCallback, Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, TArg2, TArg3, Object)	Creates a Task<TResult> that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.
FromAsync<TArg1,TArg2,TArg3>(Func<TArg1,TArg2,TArg3,AsyncCallback, Object,IAsyncResult>, Action<IAsyncResult>, TArg1, TArg2, TArg3, Object, TaskCreationOptions)	Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.
FromAsync<TArg1,TArg2,TArg3>(Func<TArg1,TArg2,TArg3,AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, TArg1, TArg2, TArg3, Object)	Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.
FromAsync<TArg1,TArg2,TResult>(Func<TArg1,TArg2,AsyncCallback, Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, TArg2, Object, TaskCreationOptions)	Creates a Task<TResult> that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.
FromAsync<TArg1,TArg2,TResult>(Func<TArg1,TArg2,AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, TArg2, Object)	Creates a Task<TResult> that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.
FromAsync<TArg1,TArg2>(Func<TArg1,TArg2,AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, TArg1, TArg2, Object, TaskCreationOptions)	Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.
FromAsync<TArg1,TArg2>(Func<TArg1,TArg2,AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, TArg1, TArg2, Object)	Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.
FromAsync<TArg1,TResult>(Func<TArg1,AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, Object, TaskCreationOptions)	Creates a Task<TResult> that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.
FromAsync<TArg1,TResult>(Func<TArg1,AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, Object)	Creates a Task<TResult> that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.
FromAsync<TArg1>(Func<TArg1,AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, TArg1, Object, TaskCreationOptions)	Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.
FromAsync<TArg1>(Func<TArg1,AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, TArg1, Object)	Creates a Task that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.
FromAsync<TResult>(Func<AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, Object, TaskCreationOptions)	Creates a Task<TResult> that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.
FromAsync<TResult>(Func<AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, Object)	Creates a Task<TResult> that represents a pair of begin and end methods that conform to the Asynchronous Programming Model pattern.
FromAsync<TResult>(IAsyncResult, Func<IAsyncResult,TResult>, TaskCreationOptions, TaskScheduler)	Creates a Task<TResult> that executes an end method function when a specified IAsyncResult completes.
FromAsync<TResult>(IAsyncResult, Func<IAsyncResult,TResult>, TaskCreationOptions)	Creates a Task<TResult> that executes an end method function when a specified IAsyncResult completes.
FromAsync<TResult>(IAsyncResult, Func<IAsyncResult,TResult>)	Creates a Task<TResult> that executes an end method function when a specified IAsyncResult completes.
GetHashCode()	Serves as the default hash function. (Inherited from Object)
GetType()	Gets the Type of the current instance. (Inherited from Object)
MemberwiseClone()	Creates a shallow copy of the current Object. (Inherited from Object)
StartNew(Action, CancellationToken, TaskCreationOptions, TaskScheduler)	Creates and starts a task for the specified action delegate, cancellation token, creation options and state.
StartNew(Action, CancellationToken)	Creates and starts a task for the specified action delegate and cancellation token.
StartNew(Action, TaskCreationOptions)	Creates and starts a task for the specified action delegate and creation options.
StartNew(Action)	Creates and starts a task for the specified action delegate.
StartNew(Action<Object>, Object, CancellationToken, TaskCreationOptions, TaskScheduler)	Creates and starts a task for the specified action delegate, state, cancellation token, creation options and task scheduler.
StartNew(Action<Object>, Object, CancellationToken)	Creates and starts a task for the specified action delegate, state and cancellation token.
StartNew(Action<Object>, Object, TaskCreationOptions)	Creates and starts a task for the specified action delegate, state and creation options.
StartNew(Action<Object>, Object)	Creates and starts a task for the specified action delegate and state.
StartNew<TResult>(Func<Object,TResult>, Object, CancellationToken, TaskCreationOptions, TaskScheduler)	Creates and starts a task of type `TResult` for the specified function delegate, state, cancellation token, creation options and task scheduler.
StartNew<TResult>(Func<Object,TResult>, Object, CancellationToken)	Creates and starts a task of type `TResult` for the specified function delegate, state and cancellation token.
StartNew<TResult>(Func<Object,TResult>, Object, TaskCreationOptions)	Creates and starts a task of type `TResult` for the specified function delegate, state and creation options.
StartNew<TResult>(Func<Object,TResult>, Object)	Creates and starts a task of type `TResult` for the specified function delegate and state.
StartNew<TResult>(Func<TResult>, CancellationToken, TaskCreationOptions, TaskScheduler)	Creates and starts a task of type `TResult` for the specified function delegate, cancellation token, creation options and task scheduler.
StartNew<TResult>(Func<TResult>, CancellationToken)	Creates and starts a task of type `TResult` for the specified function delegate and cancellation token.
StartNew<TResult>(Func<TResult>, TaskCreationOptions)	Creates and starts a task of type `TResult` for the specified function delegate and creation options.
StartNew<TResult>(Func<TResult>)	Creates and starts a task of type `TResult` for the specified function delegate.
ToString()	Returns a string that represents the current object. (Inherited from Object)

Applies to

Thread Safety

All public and protected members of TaskFactory are thread-safe and may be used concurrently from multiple threads.

Deila með