TaskFactory<TResult> Classe

Définition

generic <typename TResult>
public ref class TaskFactory

public class TaskFactory<TResult>

type TaskFactory<'Result> = class

Public Class TaskFactory(Of TResult)

Paramètres de type

Héritage

Object

TaskFactory<TResult>

Exemples

L’exemple suivant utilise la propriété statique Factory pour effectuer deux appels à la TaskFactory<TResult>.StartNew méthode. La première tâche retourne un tableau de chaînes renseigné avec les noms de fichiers dans le répertoire MyDocuments de l’utilisateur, tandis que le second retourne un tableau de chaînes renseigné avec les noms des sous-répertoires de l’utilisateur MyDocuments. 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 tableaux retournés par les deux tâches après leur exécution.

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

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

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

      Task.Factory.ContinueWhenAll(tasks, completedTasks => {
                                             Console.WriteLine("{0} contains: ", docsDirectory);
                                             Console.WriteLine("   {0} subdirectories", tasks[1].Result.Length);
                                             Console.WriteLine("   {0} files", tasks[0].Result.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(Of String())
      Dim docsDirectory As String = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments)
      
      tasks(0) = Task(Of String()).Factory.StartNew( Function()Directory.GetFiles(docsDirectory) )
''                                        End Sub )
      tasks(1) = Task(Of String()).Factory.StartNew( Function() Directory.GetDirectories(docsDirectory) )
''                                        End Sub )
      Task.Factory.ContinueWhenAll(tasks, Sub(completedTasks)
                                             Console.WriteLine("{0} contains: ", docsDirectory)
                                             Console.WriteLine("   {0} subdirectories", tasks(1).Result.Length)
                                             Console.WriteLine("   {0} files", tasks(0).Result.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.

• Classe TaskFactory<TResult> , qui crée des Task<TResult> objets.

La TaskFactory<TResult> 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. Vous pouvez appeler les surcharges de cette méthode pour créer et exécuter une tâche qui nécessite des arguments non par défaut.

  Avertissement

  À compter de .NET Framework 4.5, la Task.Run méthode fournit le moyen le plus simple de créer une tâche avec des valeurs de configuration par défaut et de le 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 ou en appelant la ContinueWhenAny 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 ou en appelant la ContinueWhenAll 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<TResult> classes pour configurer les Task<TResult> objets créés par la TaskFactory<TResult> classe. L’exemple suivant configure un nouvel TaskFactory<TResult> 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;

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

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

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

   static int DoWork()
   {
       /*...*/
       return DateTime.Now.Hour <= 12 ?  1 : 2;
    }
}

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(Of Integer)(
                         cts.Token,
                         TaskCreationOptions.PreferFairness,
                         TaskContinuationOptions.ExecuteSynchronously,
                         New CustomScheduler())

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

   Function DoWork() As Integer
      Return If(Date.Now.Hour <= 12, 1, 2)
   End Function
End Module

Dans la plupart des cas, vous n’avez pas besoin d’instancier une nouvelle TaskFactory<TResult> instance. Au lieu de cela, vous pouvez utiliser la propriété statique Task<TResult>.Factory , 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

Propriétés

Méthodes

S’applique à

Cohérence de thread

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

Voir aussi

• Bibliothèque parallèle de tâches