TaskFactory<TResult> Classe

Définition

Espace de noms:: System.Threading.Tasks

Assemblys:: mscorlib.dll, System.Threading.Tasks.dll

Assemblys:: netstandard.dll, System.Runtime.dll

Assembly:: System.Threading.Tasks.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Source:: FutureFactory.cs

Source:: TaskFactory_T.cs

Source:: FutureFactory.cs

Source:: FutureFactory.cs

Source:: FutureFactory.cs

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<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 retour des Task<TResult> objets créés par les méthodes de cette classe.

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 rempli avec les noms de fichiers dans le répertoire MyDocuments de l’utilisateur, tandis que le second retourne un tableau de chaînes rempli 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 tableaux retournés par les deux tâches une fois l’exécution terminée.

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 offre 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 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 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> classe 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âche, 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

Nom	Description
TaskFactory<TResult>()	Initialise une TaskFactory<TResult> instance avec la configuration par défaut.
TaskFactory<TResult>(CancellationToken, TaskCreationOptions, TaskContinuationOptions, TaskScheduler)	Initialise une TaskFactory<TResult> instance avec la configuration spécifiée.
TaskFactory<TResult>(CancellationToken)	Initialise une TaskFactory<TResult> instance avec la configuration par défaut.
TaskFactory<TResult>(TaskCreationOptions, TaskContinuationOptions)	Initialise une TaskFactory<TResult> instance avec la configuration spécifiée.
TaskFactory<TResult>(TaskScheduler)	Initialise une TaskFactory<TResult> instance avec la configuration spécifiée.

Propriétés

Nom	Description
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	Obtient le planificateur de tâches pour cette fabrique de tâches.

Méthodes

Nom	Description
ContinueWhenAll(Task[], Func<Task[],TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crée une tâche de continuation qui sera démarrée lors de l’achèvement d’un ensemble de tâches fournies.
ContinueWhenAll(Task[], Func<Task[],TResult>, CancellationToken)	Crée une tâche de continuation qui sera démarrée lors de l’achèvement d’un ensemble de tâches fournies.
ContinueWhenAll(Task[], Func<Task[],TResult>, TaskContinuationOptions)	Crée une tâche de continuation qui sera démarrée lors de l’achèvement d’un ensemble de tâches fournies.
ContinueWhenAll(Task[], Func<Task[],TResult>)	Crée une tâche de continuation qui sera démarrée lors de l’achèvement d’un ensemble de tâches fournies.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crée une tâche de continuation qui sera démarrée lors de l’achèvement d’un ensemble de tâches fournies.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken)	Crée une tâche de continuation qui sera démarrée lors de l’achèvement d’un ensemble de tâches fournies.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, TaskContinuationOptions)	Crée une tâche de continuation qui sera démarrée lors de l’achèvement d’un ensemble de tâches fournies.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>)	Crée une tâche de continuation qui sera démarrée lors de l’achèvement d’un ensemble de tâches fournies.
ContinueWhenAny(Task[], Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crée une tâche de continuation qui sera démarrée lors de l’achèvement d’une tâche dans l’ensemble fourni.
ContinueWhenAny(Task[], Func<Task,TResult>, CancellationToken)	Crée une tâche de continuation qui sera démarrée lors de l’achèvement d’une tâche dans l’ensemble fourni.
ContinueWhenAny(Task[], Func<Task,TResult>, TaskContinuationOptions)	Crée une tâche de continuation qui sera démarrée lors de l’achèvement d’une tâche dans l’ensemble fourni.
ContinueWhenAny(Task[], Func<Task,TResult>)	Crée une tâche de continuation qui sera démarrée lors de l’achèvement d’une tâche dans l’ensemble fourni.
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crée une tâche de continuation qui sera démarrée lors de l’achèvement d’une tâche dans l’ensemble fourni.
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>, CancellationToken)	Crée une tâche de continuation qui sera démarrée lors de l’achèvement d’une tâche dans l’ensemble fourni.
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>, TaskContinuationOptions)	Crée une tâche de continuation qui sera démarrée lors de l’achèvement d’une tâche dans l’ensemble fourni.
ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>,TResult>)	Crée une tâche de continuation qui sera démarrée lors de l’achèvement d’une tâche dans l’ensemble fourni.
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, TaskCreationOptions)	Crée une tâche qui représente une paire de méthodes de début et de fin qui sont conformes au modèle de modèle de programmation asynchrone.
FromAsync(Func<AsyncCallback,Object,IAsyncResult>, Func<IAsyncResult,TResult>, Object)	Crée une tâche qui représente une paire de méthodes de début et de fin qui sont conformes au modèle de modèle de programmation asynchrone.
FromAsync(IAsyncResult, Func<IAsyncResult,TResult>, TaskCreationOptions, TaskScheduler)	Crée une tâche qui exécute une fonction de méthode de fin lorsqu’une tâche spécifiée IAsyncResult est terminée.
FromAsync(IAsyncResult, Func<IAsyncResult,TResult>, TaskCreationOptions)	Crée une tâche qui exécute une fonction de méthode de fin lorsqu’une tâche spécifiée IAsyncResult est terminée.
FromAsync(IAsyncResult, Func<IAsyncResult,TResult>)	Crée une tâche qui exécute une fonction de méthode de fin lorsqu’une tâche spécifiée IAsyncResult est terminée.
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 de début et de fin qui sont conformes au modèle de modèle de programmation asynchrone.
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 de début et de fin qui sont conformes au modèle de 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 de début et de fin qui sont conformes au modèle de 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 de début et de fin qui sont conformes au modèle de 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 de début et de fin qui sont conformes au modèle de 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 de début et de fin qui sont conformes au modèle de modèle de programmation asynchrone.
GetHashCode()	Sert de fonction de hachage par défaut. (Hérité de Object)
GetType()	Obtient la Type de l’instance actuelle. (Hérité de Object)
MemberwiseClone()	Crée une copie superficielle du Objectactuel. (Hérité de Object)
StartNew(Func<Object,TResult>, Object, CancellationToken, TaskCreationOptions, TaskScheduler)	Crée et démarre une tâche.
StartNew(Func<Object,TResult>, Object, CancellationToken)	Crée et démarre une tâche.
StartNew(Func<Object,TResult>, Object, TaskCreationOptions)	Crée et démarre une tâche.
StartNew(Func<Object,TResult>, Object)	Crée et démarre une tâche.
StartNew(Func<TResult>, CancellationToken, TaskCreationOptions, TaskScheduler)	Crée et démarre une tâche.
StartNew(Func<TResult>, CancellationToken)	Crée et démarre une tâche.
StartNew(Func<TResult>, TaskCreationOptions)	Crée et démarre une tâche.
StartNew(Func<TResult>)	Crée et démarre 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 sont TaskFactory<TResult> thread-safe et peuvent être utilisés simultanément à partir de plusieurs threads.

Voir aussi

Bibliothèque parallèle de tâches (TPL)

Commentaires

Cette page a-t-elle été utile ?