TaskFactory<TResult> Classe
Définition
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 TaskFactorypublic class TaskFactory<TResult>type TaskFactory<'Result> = classPublic 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 :
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
| 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
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.