Partager via


TaskFactory<TResult> Classe

Définition

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

generic <typename TResult>
public ref class TaskFactory
public class TaskFactory<TResult>
type TaskFactory<'Result> = class
Public Class TaskFactory(Of TResult)

Paramètres de type

TResult

Valeur de renvoi des objets Task<TResult> que créent les méthodes de cette classe.

Héritage
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 :

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

TaskFactory<TResult>()

Initialise une instance de TaskFactory<TResult> avec la configuration par défaut.

TaskFactory<TResult>(CancellationToken)

Initialise une instance de TaskFactory<TResult> avec la configuration par défaut.

TaskFactory<TResult>(CancellationToken, TaskCreationOptions, TaskContinuationOptions, TaskScheduler)

Initialise une instance de TaskFactory<TResult> avec la configuration spécifiée.

TaskFactory<TResult>(TaskCreationOptions, TaskContinuationOptions)

Initialise une instance de TaskFactory<TResult> avec la configuration spécifiée.

TaskFactory<TResult>(TaskScheduler)

Initialise une instance de TaskFactory<TResult> 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 la valeur d'énumération TaskContinuationOptions de cette fabrique de tâches.

CreationOptions

Obtient la valeur d'énumération TaskCreationOptions de cette fabrique de tâches.

Scheduler

Retourne le planificateur de tâches pour cette fabrique.

Méthodes

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

Crée une tâche de continuation qui démarrera lorsqu’un ensemble de tâches fournies se terminera.

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

Crée une tâche de continuation qui démarrera lorsqu’un ensemble de tâches fournies se terminera.

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

Crée une tâche de continuation qui démarrera lorsqu’un ensemble de tâches fournies se terminera.

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

Crée une tâche de continuation qui démarrera lorsqu’un ensemble de tâches fournies se terminera.

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

Crée une tâche de continuation qui démarrera lorsqu’un ensemble de tâches fournies se terminera.

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

Crée une tâche de continuation qui démarrera lorsqu’un ensemble de tâches fournies se terminera.

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

Crée une tâche de continuation qui démarrera lorsqu’un ensemble de tâches fournies se terminera.

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

Crée une tâche de continuation qui démarrera lorsqu’un ensemble de tâches fournies se terminera.

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

Crée une tâche de continuation qui démarrera lorsque l’une des tâches de l’ensemble fourni se terminera.

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

Crée une tâche de continuation qui démarrera lorsque l’une des tâches de l’ensemble fourni se terminera.

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

Crée une tâche de continuation qui démarrera lorsque l’une des tâches de l’ensemble fourni se terminera.

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

Crée une tâche de continuation qui démarrera lorsque l’une des tâches de l’ensemble fourni se terminera.

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

Crée une tâche de continuation qui démarrera lorsque l’une des tâches de l’ensemble fourni se terminera.

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

Crée une tâche de continuation qui démarrera lorsque l’une des tâches de l’ensemble fourni se terminera.

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

Crée une tâche de continuation qui démarrera lorsque l’une des tâches de l’ensemble fourni se terminera.

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

Crée une tâche de continuation qui démarrera lorsque 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>, Func<IAsyncResult,TResult>, Object)

Crée une tâche qui représente une paire de méthodes Begin et End conformes au modèle de programmation asynchrone.

FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, Object, TaskCreationOptions)

Crée une tâche qui représente une paire de méthodes Begin et End conformes au modèle de programmation asynchrone.

FromAsync(IAsyncResult, Func<IAsyncResult,TResult>)

Crée une tâche qui exécute une fonction de méthode End lorsqu'un IAsyncResult spécifié se termine.

FromAsync(IAsyncResult, Func<IAsyncResult,TResult>, TaskCreationOptions)

Crée une tâche qui exécute une fonction de méthode End lorsqu'un IAsyncResult spécifié se termine.

FromAsync(IAsyncResult, Func<IAsyncResult,TResult>, TaskCreationOptions, TaskScheduler)

Crée une tâche qui exécute une fonction de méthode End lorsqu'un IAsyncResult spécifié se termine.

FromAsync<TArg1,TArg2,TArg3>(Func<TArg1,TArg2,TArg3,AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, TArg1, TArg2, TArg3, Object)

Crée une tâche 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>, Func<IAsyncResult,TResult>, TArg1, TArg2, TArg3, Object, TaskCreationOptions)

Crée une tâche 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>, Func<IAsyncResult,TResult>, TArg1, TArg2, Object)

Crée une tâche 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>, Func<IAsyncResult,TResult>, TArg1, TArg2, Object, TaskCreationOptions)

Crée une tâche 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>, Func<IAsyncResult,TResult>, TArg1, Object)

Crée une tâche 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>, Func<IAsyncResult,TResult>, TArg1, Object, TaskCreationOptions)

Crée une tâche qui représente une paire de méthodes Begin et End conformes au modèle de programmation asynchrone.

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(Func<Object,TResult>, Object)

Crée et lance une tâche.

StartNew(Func<Object,TResult>, Object, CancellationToken)

Crée et lance une tâche.

StartNew(Func<Object,TResult>, Object, CancellationToken, TaskCreationOptions, TaskScheduler)

Crée et lance une tâche.

StartNew(Func<Object,TResult>, Object, TaskCreationOptions)

Crée et lance une tâche.

StartNew(Func<TResult>)

Crée et lance une tâche.

StartNew(Func<TResult>, CancellationToken)

Crée et lance une tâche.

StartNew(Func<TResult>, CancellationToken, TaskCreationOptions, TaskScheduler)

Crée et lance une tâche.

StartNew(Func<TResult>, TaskCreationOptions)

Crée et lance une tâche.

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<TResult> sont thread-safe et peuvent être utilisés simultanément par plusieurs threads.

Voir aussi