TaskFactory Classe

Référence

Définition

Espace de noms:: System.Threading.Tasks

Assembly:: System.Threading.Tasks.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Prend en charge la création et la planification d'objets Task.

public ref class TaskFactory

public class TaskFactory

type TaskFactory = class

Public Class TaskFactory

Héritage: Object
TaskFactory

Exemples

L’exemple suivant utilise la propriété statique Factory pour effectuer deux appels à la TaskFactory.StartNew méthode. Le premier remplit un tableau avec les noms de fichiers dans le répertoire MyDocuments de l’utilisateur, tandis que le second remplit un tableau avec les noms des sous-répertoires du répertoire MyDocuments de l’utilisateur. Il appelle ensuite la TaskFactory.ContinueWhenAll(Task[], Action<Task[]>) méthode, qui affiche des informations sur le nombre de fichiers et de répertoires dans les deux tableaux après l’exécution des deux premières tâches.

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

Remarques

.NET fournit deux fabriques pour créer et planifier des tâches :

Classe TaskFactory , qui crée Task et Task<TResult> objets. Vous pouvez appeler les surcharges de cette méthode pour créer et exécuter une tâche qui nécessite des arguments autres que ceux par défaut.

Avertissement

À compter de .NET Framework 4.5, la Task.Run méthode offre le moyen le plus simple de créer une tâche avec les valeurs de configuration par défaut et de la démarrer immédiatement.
Classe TaskFactory<TResult> , qui crée des Task<TResult> objets.

La TaskFactory classe vous permet d’effectuer les opérations suivantes :

Créez une tâche et démarrez-la immédiatement en appelant la StartNew méthode.

Avertissement

À compter de .NET Framework 4.5, la Task.Run méthode offre le moyen le plus simple de créer une tâche avec les valeurs de configuration par défaut et de la démarrer immédiatement.
Créez une tâche qui démarre lorsque l’une des tâches d’un tableau est terminée en appelant la ContinueWhenAny méthode.
Créez une tâche qui démarre lorsque toutes les tâches d’un tableau ont été effectuées en appelant la ContinueWhenAll méthode.

La propriété statique Task<TResult>.Factory retourne un objet par défaut TaskFactory<TResult> . Vous pouvez également appeler l’un des constructeurs de TaskFactory classe pour configurer les Task objets créés par la TaskFactory classe. L’exemple suivant configure un nouvel TaskFactory objet pour créer des tâches qui ont un jeton d’annulation spécifié, des options de création de tâches, des options de continuation et un planificateur de tâches personnalisé.

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

Dans la plupart des cas, vous n’avez pas besoin d’instancier une nouvelle TaskFactory instance. Au lieu de cela, vous pouvez utiliser la Task.Factory propriété, qui retourne un objet de fabrique qui utilise des valeurs par défaut. Vous pouvez ensuite appeler ses méthodes pour démarrer de nouvelles tâches ou définir des continuations de tâches. Pour obtenir une illustration, consultez l’exemple.

Constructeurs

TaskFactory()	Initialise une instance de TaskFactory avec la configuration par défaut.
TaskFactory(CancellationToken)	Initialise une instance de TaskFactory avec la configuration spécifiée.
TaskFactory(CancellationToken, TaskCreationOptions, TaskContinuationOptions, TaskScheduler)	Initialise une instance de TaskFactory avec la configuration spécifiée.
TaskFactory(TaskCreationOptions, TaskContinuationOptions)	Initialise une instance de TaskFactory avec la configuration spécifiée.
TaskFactory(TaskScheduler)	Initialise une instance de TaskFactory avec la configuration spécifiée.

Propriétés

CancellationToken	Obtient le jeton d’annulation par défaut pour cette fabrique de tâches.
ContinuationOptions	Obtient les options de continuation de tâches par défaut pour cette fabrique de tâches.
CreationOptions	Obtient les options de création de tâches par défaut pour cette fabrique de tâches.
Scheduler	Obtient le planificateur de tâches par défaut pour cette fabrique de tâches.

Méthodes

ContinueWhenAll(Task[], Action<Task[]>)	Crée une tâche de continuation qui démarre lorsqu'un ensemble de tâches spécifiées est terminé.
ContinueWhenAll(Task[], Action<Task[]>, CancellationToken)	Crée une tâche de continuation qui démarre lorsqu'un ensemble de tâches spécifiées est terminé.
ContinueWhenAll(Task[], Action<Task[]>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crée une tâche de continuation qui démarre lorsqu'un ensemble de tâches spécifiées est terminé.
ContinueWhenAll(Task[], Action<Task[]>, TaskContinuationOptions)	Crée une tâche de continuation qui démarre lorsqu'un ensemble de tâches spécifiées est terminé.
ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>)	Crée une tâche de continuation qui démarre lorsqu'un ensemble de tâches spécifiées est terminé.
ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken)	Crée une tâche de continuation qui démarre lorsqu'un ensemble de tâches spécifiées est terminé.
ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crée une tâche de continuation qui démarre lorsqu'un ensemble de tâches spécifiées est terminé.
ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, TaskContinuationOptions)	Crée une tâche de continuation qui démarre lorsqu'un ensemble de tâches spécifiées est terminé.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>)	Crée une tâche de continuation qui démarre lorsqu'un ensemble de tâches spécifiées est terminé.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>, CancellationToken)	Crée une tâche de continuation qui démarre lorsqu'un ensemble de tâches spécifiées est terminé.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crée une tâche de continuation qui démarre lorsqu'un ensemble de tâches spécifiées est terminé.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>, TaskContinuationOptions)	Crée une tâche de continuation qui démarre lorsqu'un ensemble de tâches spécifiées est terminé.
ContinueWhenAll<TResult>(Task[], Func<Task[],TResult>)	Crée une tâche de continuation qui démarre lorsqu'un ensemble de tâches spécifiées est terminé.
ContinueWhenAll<TResult>(Task[], Func<Task[],TResult>, CancellationToken)	Crée une tâche de continuation qui démarre lorsqu'un ensemble de tâches spécifiées est terminé.
ContinueWhenAll<TResult>(Task[], Func<Task[],TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crée une tâche de continuation qui démarre lorsqu'un ensemble de tâches spécifiées est terminé.
ContinueWhenAll<TResult>(Task[], Func<Task[],TResult>, TaskContinuationOptions)	Crée une tâche de continuation qui démarre lorsqu'un ensemble de tâches spécifiées est terminé.
ContinueWhenAny(Task[], Action<Task>)	Crée une Task de continuation qui démarrera quand l'une des tâches de l'ensemble fourni se terminera.
ContinueWhenAny(Task[], Action<Task>, CancellationToken)	Crée une Task de continuation qui démarrera quand l'une des tâches de l'ensemble fourni se terminera.
ContinueWhenAny(Task[], Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crée une Task de continuation qui démarrera quand l'une des tâches de l'ensemble fourni se terminera.
ContinueWhenAny(Task[], Action<Task>, TaskContinuationOptions)	Crée une Task de continuation qui démarrera quand l'une des tâches de l'ensemble fourni se terminera.
ContinueWhenAny<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>)	Crée une Task<TResult> de continuation qui démarrera quand l'une des tâches de l'ensemble fourni se terminera.
ContinueWhenAny<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>, CancellationToken)	Crée une Task<TResult> de continuation qui démarrera quand l'une des tâches de l'ensemble fourni se terminera.
ContinueWhenAny<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crée une Task<TResult> de continuation qui démarrera quand l'une des tâches de l'ensemble fourni se terminera.
ContinueWhenAny<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>, TaskContinuationOptions)	Crée une Task<TResult> de continuation qui démarrera quand l'une des tâches de l'ensemble fourni se terminera.
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>>)	Crée une Task de continuation qui démarrera quand l'une des tâches de l'ensemble fourni se terminera.
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>>, CancellationToken)	Crée une Task de continuation qui démarrera quand l'une des tâches de l'ensemble fourni se terminera.
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crée une Task de continuation qui démarrera quand l'une des tâches de l'ensemble fourni se terminera.
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>>, TaskContinuationOptions)	Crée une Task de continuation qui démarrera quand l'une des tâches de l'ensemble fourni se terminera.
ContinueWhenAny<TResult>(Task[], Func<Task,TResult>)	Crée une Task<TResult> de continuation qui démarrera quand l'une des tâches de l'ensemble fourni se terminera.
ContinueWhenAny<TResult>(Task[], Func<Task,TResult>, CancellationToken)	Crée une Task<TResult> de continuation qui démarrera quand l'une des tâches de l'ensemble fourni se terminera.
ContinueWhenAny<TResult>(Task[], Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crée une Task<TResult> de continuation qui démarrera quand l'une des tâches de l'ensemble fourni se terminera.
ContinueWhenAny<TResult>(Task[], Func<Task,TResult>, TaskContinuationOptions)	Crée une Task<TResult> de continuation qui démarrera quand l'une des tâches de l'ensemble fourni se terminera.
Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object)	Crée un Task qui représente une paire de méthodes Begin et End conformes au modèle de programmation asynchrone.
FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, Object, TaskCreationOptions)	Crée un Task qui représente une paire de méthodes Begin et End conformes au modèle de programmation asynchrone.
FromAsync(IAsyncResult, Action<IAsyncResult>)	Crée une Task qui exécute une action de la méthode End quand un IAsyncResult spécifié se termine.
FromAsync(IAsyncResult, Action<IAsyncResult>, TaskCreationOptions)	Crée une Task qui exécute une action de la méthode End quand un IAsyncResult spécifié se termine.
FromAsync(IAsyncResult, Action<IAsyncResult>, TaskCreationOptions, TaskScheduler)	Crée une Task qui exécute une action de la méthode End quand un IAsyncResult spécifié se termine.
FromAsync<TArg1,TArg2,TArg3,TResult>(Func<TArg1,TArg2,TArg3,AsyncCallback, Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, TArg2, TArg3, Object)	Crée un Task<TResult> qui représente une paire de méthodes Begin et End conformes au modèle de programmation asynchrone.
FromAsync<TArg1,TArg2,TArg3,TResult>(Func<TArg1,TArg2,TArg3,AsyncCallback, Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, TArg2, TArg3, Object, TaskCreationOptions)	Crée un Task<TResult> qui représente une paire de méthodes Begin et End conformes au modèle de programmation asynchrone.
FromAsync<TArg1,TArg2,TArg3>(Func<TArg1,TArg2,TArg3,AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, TArg1, TArg2, TArg3, Object)	Crée un Task qui représente une paire de méthodes Begin et End conformes au modèle de programmation asynchrone.
FromAsync<TArg1,TArg2,TArg3>(Func<TArg1,TArg2,TArg3,AsyncCallback, Object,IAsyncResult>, Action<IAsyncResult>, TArg1, TArg2, TArg3, Object, TaskCreationOptions)	Crée un Task qui représente une paire de méthodes Begin et End conformes au modèle de programmation asynchrone.
FromAsync<TArg1,TArg2,TResult>(Func<TArg1,TArg2,AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, TArg2, Object)	Crée un Task<TResult> qui représente une paire de méthodes Begin et End conformes au modèle de programmation asynchrone.
FromAsync<TArg1,TArg2,TResult>(Func<TArg1,TArg2,AsyncCallback, Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, TArg2, Object, TaskCreationOptions)	Crée un Task<TResult> qui représente une paire de méthodes Begin et End conformes au modèle de programmation asynchrone.
FromAsync<TArg1,TArg2>(Func<TArg1,TArg2,AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, TArg1, TArg2, Object)	Crée un Task qui représente une paire de méthodes Begin et End conformes au modèle de programmation asynchrone.
FromAsync<TArg1,TArg2>(Func<TArg1,TArg2,AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, TArg1, TArg2, Object, TaskCreationOptions)	Crée un Task qui représente une paire de méthodes Begin et End conformes au modèle de programmation asynchrone.
FromAsync<TArg1,TResult>(Func<TArg1,AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, Object)	Crée un Task<TResult> qui représente une paire de méthodes Begin et End conformes au modèle de programmation asynchrone.
FromAsync<TArg1,TResult>(Func<TArg1,AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, Object, TaskCreationOptions)	Crée un Task<TResult> qui représente une paire de méthodes Begin et End conformes au modèle de programmation asynchrone.
FromAsync<TArg1>(Func<TArg1,AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, TArg1, Object)	Crée un Task qui représente une paire de méthodes Begin et End conformes au modèle de programmation asynchrone.
FromAsync<TArg1>(Func<TArg1,AsyncCallback,Object,IAsyncResult>, Action<IAsyncResult>, TArg1, Object, TaskCreationOptions)	Crée un Task qui représente une paire de méthodes Begin et End conformes au modèle de programmation asynchrone.
FromAsync<TResult>(Func<AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, Object)	Crée un Task<TResult> qui représente une paire de méthodes Begin et End conformes au modèle de programmation asynchrone.
FromAsync<TResult>(Func<AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, Object, TaskCreationOptions)	Crée un Task<TResult> qui représente une paire de méthodes Begin et End conformes au modèle de programmation asynchrone.
FromAsync<TResult>(IAsyncResult, Func<IAsyncResult,TResult>)	Crée un Task<TResult> qui exécute une fonction de méthode End quand un IAsyncResult spécifié se termine.
FromAsync<TResult>(IAsyncResult, Func<IAsyncResult,TResult>, TaskCreationOptions)	Crée un Task<TResult> qui exécute une fonction de méthode End quand un IAsyncResult spécifié se termine.
FromAsync<TResult>(IAsyncResult, Func<IAsyncResult,TResult>, TaskCreationOptions, TaskScheduler)	Crée un Task<TResult> qui exécute une fonction de méthode End lorsqu'un IAsyncResult spécifié se termine.
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
StartNew(Action)	Crée et démarre une tâche pour le délégué d’action spécifié.
StartNew(Action, CancellationToken)	Crée et démarre une tâche pour le délégué d’action et le jeton d’annulation spécifiés.
StartNew(Action, CancellationToken, TaskCreationOptions, TaskScheduler)	Crée et démarre une tâche pour le délégué d’action, le jeton d’annulation, les options de création et l’état spécifiés.
StartNew(Action, TaskCreationOptions)	Crée et démarre une tâche pour les options de délégué et de création d’action spécifiées.
StartNew(Action<Object>, Object)	Crée et démarre une tâche pour le délégué et l’état d’action spécifiés.
StartNew(Action<Object>, Object, CancellationToken)	Crée et démarre une tâche pour le délégué d’action, l’état et le jeton d’annulation spécifiés.
StartNew(Action<Object>, Object, CancellationToken, TaskCreationOptions, TaskScheduler)	Crée et démarre une tâche pour le délégué d’action, l’état, le jeton d’annulation, les options de création et le planificateur de tâches spécifiés.
StartNew(Action<Object>, Object, TaskCreationOptions)	Crée et démarre une tâche pour le délégué d’action, l’état et les options de création spécifiés.
StartNew<TResult>(Func<Object,TResult>, Object)	Crée et démarre une tâche de type `TResult` pour le délégué de fonction et l’état spécifiés.
StartNew<TResult>(Func<Object,TResult>, Object, CancellationToken)	Crée et démarre une tâche de type `TResult` pour le délégué de fonction, l’état et le jeton d’annulation spécifiés.
StartNew<TResult>(Func<Object,TResult>, Object, CancellationToken, TaskCreationOptions, TaskScheduler)	Crée et démarre une tâche de type `TResult` pour le délégué de fonction, l’état, le jeton d’annulation, les options de création et le planificateur de tâches spécifiés.
StartNew<TResult>(Func<Object,TResult>, Object, TaskCreationOptions)	Crée et démarre une tâche de type `TResult` pour le délégué de fonction, l’état et les options de création spécifiés.
StartNew<TResult>(Func<TResult>)	Crée et démarre une tâche de type `TResult` pour le délégué de fonction spécifié.
StartNew<TResult>(Func<TResult>, CancellationToken)	Crée et démarre une tâche de type `TResult` pour le délégué de fonction et le jeton d’annulation spécifiés.
StartNew<TResult>(Func<TResult>, CancellationToken, TaskCreationOptions, TaskScheduler)	Crée et démarre une tâche de type `TResult` pour le délégué de fonction, le jeton d’annulation, les options de création et le planificateur de tâches spécifiés.
StartNew<TResult>(Func<TResult>, TaskCreationOptions)	Crée et démarre une tâche de type `TResult` pour le délégué de fonction et les options de création spécifiés.
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)

S’applique à

Cohérence de thread

Tous les membres publics et protégés de TaskFactory sont thread-safe et peuvent être utilisés simultanément par plusieurs threads.