Task<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:: Future.cs

Source:: Task_T.cs

Source:: Future.cs

Source:: Future.cs

Source:: Future.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.

Représente une opération asynchrone qui peut retourner une valeur.

generic <typename TResult>
public ref class Task : System::Threading::Tasks::Task

public class Task<TResult> : System.Threading.Tasks.Task

type Task<'Result> = class
    inherit Task

Public Class Task(Of TResult)
Inherits Task

Paramètres de type

TResult

Type du résultat produit par ce Task<TResult>.

Héritage: Object

Task
Task<TResult>

Remarques

La Task<TResult> classe représente une seule opération qui retourne une valeur et qui s’exécute généralement de manière asynchrone. Task<TResult> les objets sont l’un des composants centraux du modèle asynchrone basé sur des tâches introduits en premier dans .NET Framework 4. Étant donné que le travail effectué par un Task<TResult> objet s’exécute généralement de manière asynchrone sur un thread de pool de threads plutôt que de manière synchrone sur le thread d’application principal, vous pouvez utiliser la Status propriété, ainsi que les IsCanceled IsCompletedpropriétés , et IsFaulted les propriétés, pour déterminer l’état d’une tâche. La plupart du temps, une expression lambda est utilisée pour spécifier le travail que la tâche doit effectuer.

Task<TResult> les instances peuvent être créées de différentes manières. L’approche la plus courante, disponible à partir de .NET Framework 4.5, consiste à appeler la méthode ou Task.Run<TResult>(Func<TResult>, CancellationToken) statiqueTask.Run<TResult>(Func<TResult>). Ces méthodes offrent un moyen simple de démarrer une tâche à l’aide de valeurs par défaut et sans acquérir de paramètres supplémentaires. L’exemple suivant utilise la Task.Run<TResult>(Func<TResult>) méthode pour démarrer une tâche qui effectue une boucle, puis affiche le nombre d’itérations de boucle :

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      var t = Task<int>.Run( () => {
                                      // Just loop.
                                      int max = 1000000;
                                      int ctr = 0;
                                      for (ctr = 0; ctr <= max; ctr++) {
                                         if (ctr == max / 2 && DateTime.Now.Hour <= 12) {
                                            ctr++;
                                            break;
                                         }
                                      }
                                      return ctr;
                                    } );
      Console.WriteLine("Finished {0:N0} iterations.", t.Result);
   }
}
// The example displays output like the following:
//        Finished 1,000,001 loop iterations.

Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim t As Task(Of Integer) = Task.Run(Function()
                                  Dim max As Integer = 1000000
                                  Dim ctr As Integer
                                  For ctr = 0 to max
                                     If ctr = max \ 2 And Date.Now.Hour <= 12 Then
                                        ctr += 1
                                        Exit For
                                     End If
                                  Next
                                  Return ctr
                               End Function)
      Console.WriteLine("Finished {0:N0} iterations.", t.Result)
   End Sub
End Module
' The example displays the following output:
'       Finished 1,000,001 loop iterations

Une alternative, et la méthode la plus courante pour démarrer une tâche dans .NET Framework 4, consiste à appeler la méthode ou TaskFactory<TResult>.StartNew statiqueTaskFactory.StartNew. La Task.Factory propriété retourne un TaskFactory objet et la Task<TResult>.Factory propriété renvoie un TaskFactory<TResult> objet. Les surcharges de leur StartNew méthode vous permettent de passer des arguments, de définir des options de création de tâche et de spécifier un planificateur de tâches. L’exemple suivant utilise la TaskFactory<TResult>.StartNew(Func<TResult>) méthode pour démarrer une tâche. Il est fonctionnellement équivalent au code de l’exemple précédent.

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      var t = Task<int>.Factory.StartNew( () => {
                                      // Just loop.
                                      int max = 1000000;
                                      int ctr = 0;
                                      for (ctr = 0; ctr <= max; ctr++) {
                                         if (ctr == max / 2 && DateTime.Now.Hour <= 12) {
                                            ctr++;
                                            break;
                                         }
                                      }
                                      return ctr;
                               } );
      Console.WriteLine("Finished {0:N0} iterations.", t.Result);
   }
}
// The example displays the following output:
//        Finished 1000001 loop iterations

Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim t = Task(Of Integer).Factory.StartNew(Function()
                                  Dim max As Integer = 1000000
                                  Dim ctr As Integer
                                  For ctr = 0 to max
                                     If ctr = max \ 2 And Date.Now.Hour <= 12 Then
                                       ctr += 1
                                       Exit For
                                     End If
                                  Next
                                  Return ctr
                               End Function)
      Console.WriteLine("Finished {0:N0} iterations.", t.Result)
   End Sub
End Module
' The example displays output like the following:
'       Finished 1,000,001 iterations

Pour obtenir des exemples plus complets, consultez Programmation asynchrone basée sur les tâches.

La Task<TResult> classe fournit également des constructeurs qui initialisent la tâche, mais qui ne le planifient pas pour l’exécution. Pour des raisons de performances, les méthodes et Task.Factory.StartNew les Task.Run méthodes sont les mécanismes préférés pour créer et planifier des tâches de calcul, mais pour les scénarios où la création et la planification des tâches doivent être séparées, les constructeurs peuvent être utilisés et la méthode de Start la tâche peut ensuite être utilisée pour planifier la tâche pour l’exécution ultérieurement.

À compter des applications de bureau qui ciblent .NET Framework 4.6, la culture du thread qui crée et appelle une tâche fait partie du contexte du thread. Autrement dit, quelle que soit la culture actuelle du thread sur lequel la tâche s’exécute, la culture actuelle de la tâche est la culture du thread appelant. Pour les applications qui ciblent des versions de .NET Framework antérieures à .NET Framework 4.6, la culture de la tâche est la culture du thread sur lequel la tâche s’exécute. Pour plus d’informations, consultez la section « Opérations asynchrones basées sur la culture et les tâches » dans la CultureInfo rubrique. Notez que les applications du Windows Store suivent Windows Runtime dans le paramètre et obtiennent la culture par défaut.

Pour les opérations qui ne retournent pas de valeur, vous utilisez la Task classe. À compter de C# 7.0, pour une tâche plus légère qui est un type valeur plutôt qu’un type référence, utilisez la System.Threading.Tasks.ValueTask<TResult> structure.

Constructeurs

Nom	Description
Task<TResult>(Func<Object,TResult>, Object, CancellationToken, TaskCreationOptions)	Initialise un nouveau Task<TResult> avec l’action, l’état et les options spécifiés.
Task<TResult>(Func<Object,TResult>, Object, CancellationToken)	Initialise un nouveau Task<TResult> avec l’action, l’état et les options spécifiés.
Task<TResult>(Func<Object,TResult>, Object, TaskCreationOptions)	Initialise un nouveau Task<TResult> avec l’action, l’état et les options spécifiés.
Task<TResult>(Func<Object,TResult>, Object)	Initialise un nouveau Task<TResult> avec la fonction et l’état spécifiés.
Task<TResult>(Func<TResult>, CancellationToken, TaskCreationOptions)	Initialise une nouvelle Task<TResult> fonction et les options de création spécifiées.
Task<TResult>(Func<TResult>, CancellationToken)	Initialise une nouvelle Task<TResult> avec la fonction spécifiée.
Task<TResult>(Func<TResult>, TaskCreationOptions)	Initialise une nouvelle Task<TResult> fonction et les options de création spécifiées.
Task<TResult>(Func<TResult>)	Initialise une nouvelle Task<TResult> avec la fonction spécifiée.

Propriétés

Nom	Description
AsyncState	Obtient l’objet d’état fourni lors de la création ou de la Task valeur Null si aucun n’a été fourni. (Hérité de Task)
CreationOptions	Obtient l’élément TaskCreationOptions utilisé pour créer cette tâche. (Hérité de Task)
Exception	Obtient l’élément AggregateException qui a provoqué la Task fin prématurément. Si l’opération Task s’est terminée correctement ou n’a pas encore levée d’exceptions, cela retourne `null`. (Hérité de Task)
Factory	Obtient une méthode de fabrique pour créer et configurer des Task<TResult> instances.
Id	Obtient un ID pour cette Task instance. (Hérité de Task)
IsCanceled	Obtient si cette Task instance a terminé l’exécution en raison d’une annulation. (Hérité de Task)
IsCompleted	Obtient une valeur qui indique si la tâche est terminée. (Hérité de Task)
IsCompletedSuccessfully	Obtient si la tâche s’est exécutée à la fin. (Hérité de Task)
IsFaulted	Obtient si l’opération Task terminée en raison d’une exception non gérée. (Hérité de Task)
Result	Obtient la valeur de résultat de ce Task<TResult>.
Status	Obtient la TaskStatus tâche. (Hérité de Task)

Méthodes

Nom	Description
ConfigureAwait(Boolean)	Configure un awaiter utilisé pour l’attendre Task<TResult>.
ConfigureAwait(ConfigureAwaitOptions)	Configure un awaiter utilisé pour l’attendre Task.
ContinueWith(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crée une continuation qui reçoit les informations d’état fournies par l’appelant et un jeton d’annulation et qui s’exécute une fois la cible Task terminée. La continuation s’exécute en fonction d’un ensemble de conditions spécifiées et utilise un planificateur spécifié. (Hérité de Task)
ContinueWith(Action<Task,Object>, Object, CancellationToken)	Crée une continuation qui reçoit les informations d’état fournies par l’appelant et un jeton d’annulation et qui s’exécute de manière asynchrone lorsque la cible Task se termine. (Hérité de Task)
ContinueWith(Action<Task,Object>, Object, TaskContinuationOptions)	Crée une continuation qui reçoit les informations d’état fournies par l’appelant et s’exécute une fois la cible Task terminée. La continuation s’exécute en fonction d’un ensemble de conditions spécifiées. (Hérité de Task)
ContinueWith(Action<Task,Object>, Object, TaskScheduler)	Crée une continuation qui reçoit les informations d’état fournies par l’appelant et s’exécute de façon asynchrone lorsque la cible Task se termine. La continuation utilise un planificateur spécifié. (Hérité de Task)
ContinueWith(Action<Task,Object>, Object)	Crée une continuation qui reçoit les informations d’état fournies par l’appelant et s’exécute une fois la cible Task terminée. (Hérité de Task)
ContinueWith(Action<Task<TResult>,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crée une continuation qui s’exécute une fois la cible Task<TResult> terminée.
ContinueWith(Action<Task<TResult>,Object>, Object, CancellationToken)	Crée une continuation qui s’exécute une fois la cible Task<TResult> terminée.
ContinueWith(Action<Task<TResult>,Object>, Object, TaskContinuationOptions)	Crée une continuation qui s’exécute une fois la cible Task<TResult> terminée.
ContinueWith(Action<Task<TResult>,Object>, Object, TaskScheduler)	Crée une continuation qui s’exécute une fois la cible Task<TResult> terminée.
ContinueWith(Action<Task<TResult>,Object>, Object)	Crée une continuation qui est transmise aux informations d’état et qui s’exécute une fois la cible Task<TResult> terminée.
ContinueWith(Action<Task<TResult>>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crée une continuation qui s’exécute en fonction de la condition spécifiée dans `continuationOptions`.
ContinueWith(Action<Task<TResult>>, CancellationToken)	Crée une continuation annulable qui s’exécute de façon asynchrone lorsque la cible Task<TResult> se termine.
ContinueWith(Action<Task<TResult>>, TaskContinuationOptions)	Crée une continuation qui s’exécute en fonction de la condition spécifiée dans `continuationOptions`.
ContinueWith(Action<Task<TResult>>, TaskScheduler)	Crée une continuation qui s’exécute de manière asynchrone une fois la cible Task<TResult> terminée.
ContinueWith(Action<Task<TResult>>)	Crée une continuation qui s’exécute de manière asynchrone lorsque la tâche cible se termine.
ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crée une continuation qui s’exécute lorsque la tâche cible est en concurrence en fonction de la valeur spécifiée TaskContinuationOptions. La continuation reçoit un jeton d’annulation et utilise un planificateur spécifié. (Hérité de Task)
ContinueWith(Action<Task>, CancellationToken)	Crée une continuation qui reçoit un jeton d’annulation et s’exécute de façon asynchrone une fois la cible Task terminée. (Hérité de Task)
ContinueWith(Action<Task>, TaskContinuationOptions)	Crée une continuation qui s’exécute lorsque la tâche cible se termine en fonction de la valeur spécifiée TaskContinuationOptions. (Hérité de Task)
ContinueWith(Action<Task>, TaskScheduler)	Crée une continuation qui s’exécute de manière asynchrone une fois la cible Task terminée. La continuation utilise un planificateur spécifié. (Hérité de Task)
ContinueWith(Action<Task>)	Crée une continuation qui s’exécute de manière asynchrone une fois la cible Task terminée. (Hérité de Task)
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crée une continuation qui s’exécute une fois la cible Task<TResult> terminée.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, CancellationToken)	Crée une continuation qui s’exécute une fois la cible Task<TResult> terminée.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, TaskContinuationOptions)	Crée une continuation qui s’exécute une fois la cible Task<TResult> terminée.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, TaskScheduler)	Crée une continuation qui s’exécute une fois la cible Task<TResult> terminée.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object)	Crée une continuation qui s’exécute une fois la cible Task<TResult> terminée.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crée une continuation qui s’exécute en fonction de la condition spécifiée dans `continuationOptions`.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, CancellationToken)	Crée une continuation qui s’exécute de manière asynchrone une fois la cible Task<TResult> terminée.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, TaskContinuationOptions)	Crée une continuation qui s’exécute en fonction de la condition spécifiée dans `continuationOptions`.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, TaskScheduler)	Crée une continuation qui s’exécute de manière asynchrone une fois la cible Task<TResult> terminée.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>)	Crée une continuation qui s’exécute de manière asynchrone une fois la cible Task<TResult> terminée.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crée une continuation qui s’exécute en fonction des options de continuation de tâche spécifiées lorsque la cible Task se termine et retourne une valeur. La continuation reçoit les informations d’état fournies par l’appelant et un jeton d’annulation et utilise le planificateur spécifié. (Hérité de Task)
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken)	Crée une continuation qui s’exécute de façon asynchrone lorsque la cible Task se termine et retourne une valeur. La continuation reçoit les informations d’état fournies par l’appelant et un jeton d’annulation. (Hérité de Task)
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskContinuationOptions)	Crée une continuation qui s’exécute en fonction des options de continuation de tâche spécifiées une fois la cible Task terminée. La continuation reçoit les informations d’état fournies par l’appelant. (Hérité de Task)
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskScheduler)	Crée une continuation qui s’exécute de manière asynchrone une fois la cible Task terminée. La continuation reçoit les informations d’état fournies par l’appelant et utilise un planificateur spécifié. (Hérité de Task)
ContinueWith<TResult>(Func<Task,Object,TResult>, Object)	Crée une continuation qui reçoit les informations d’état fournies par l’appelant et s’exécute de façon asynchrone lorsque la cible Task se termine et retourne une valeur. (Hérité de Task)
ContinueWith<TResult>(Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crée une continuation qui s’exécute en fonction des options de continuation spécifiées et retourne une valeur. La continuation est passée à un jeton d’annulation et utilise un planificateur spécifié. (Hérité de Task)
ContinueWith<TResult>(Func<Task,TResult>, CancellationToken)	Crée une continuation qui s’exécute de façon asynchrone lorsque la cible Task se termine et retourne une valeur. La continuation reçoit un jeton d’annulation. (Hérité de Task)
ContinueWith<TResult>(Func<Task,TResult>, TaskContinuationOptions)	Crée une continuation qui s’exécute en fonction des options de continuation spécifiées et retourne une valeur. (Hérité de Task)
ContinueWith<TResult>(Func<Task,TResult>, TaskScheduler)	Crée une continuation qui s’exécute de façon asynchrone lorsque la cible Task se termine et retourne une valeur. La continuation utilise un planificateur spécifié. (Hérité de Task)
ContinueWith<TResult>(Func<Task,TResult>)	Crée une continuation qui s’exécute de façon asynchrone lorsque la cible Task<TResult> se termine et retourne une valeur. (Hérité de Task)
Dispose()	Libère toutes les ressources utilisées par l’instance actuelle de la Task classe. (Hérité de Task)
Dispose(Boolean)	Supprime , Tasklibère toutes ses ressources non managées. (Hérité de Task)
Equals(Object)	Détermine si l’objet spécifié est égal à l’objet actuel. (Hérité de Object)
GetAwaiter()	Obtient un awaiter utilisé pour attendre ce Task<TResult>.
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)
RunSynchronously()	S’exécute Task de manière synchrone sur le fichier actif TaskScheduler. (Hérité de Task)
RunSynchronously(TaskScheduler)	Exécute la Task synchronisation sur l’élément TaskScheduler fourni. (Hérité de Task)
Start()	Démarre le Task, en le planifiant pour l’exécution vers l’actif TaskScheduler. (Hérité de Task)
Start(TaskScheduler)	Démarre le Task, en le planifiant pour l’exécution sur le fichier spécifié TaskScheduler. (Hérité de Task)
ToString()	Retourne une chaîne qui représente l’objet actuel. (Hérité de Object)
Wait()	Attend la fin de l’exécution Task . (Hérité de Task)
Wait(CancellationToken)	Attend la fin de l’exécution Task . L’attente se termine si un jeton d’annulation est annulé avant la fin de la tâche. (Hérité de Task)
Wait(Int32, CancellationToken)	Attend la fin de l’exécution Task . L’attente se termine si un intervalle de délai d’expiration s’écoule ou qu’un jeton d’annulation est annulé avant la fin de la tâche. (Hérité de Task)
Wait(Int32)	Attend la fin de l’exécution Task dans un nombre spécifié de millisecondes. (Hérité de Task)
Wait(TimeSpan, CancellationToken)	Attend la fin de l’exécution Task . (Hérité de Task)
Wait(TimeSpan)	Attend la fin de l’exécution Task dans un intervalle de temps spécifié. (Hérité de Task)
WaitAsync(CancellationToken)	Obtient une Task<TResult> opération qui se termine une fois cette Task<TResult> opération terminée ou lorsque l’annulation spécifiée a été CancellationToken demandée.
WaitAsync(TimeSpan, CancellationToken)	Obtient une Task<TResult> opération qui se termine lorsque Task<TResult> le délai d’expiration spécifié expire ou lorsque l’annulation spécifiée a été CancellationToken demandée.
WaitAsync(TimeSpan, TimeProvider, CancellationToken)	Obtient une Task<TResult> opération qui se termine lorsque Task<TResult> le délai d’expiration spécifié expire ou lorsque l’annulation spécifiée a été CancellationToken demandée.
WaitAsync(TimeSpan, TimeProvider)	Obtient une Task<TResult> valeur qui se termine une fois cette Task<TResult> opération terminée ou lorsque le délai d’expiration spécifié expire.
WaitAsync(TimeSpan)	Obtient une Task<TResult> valeur qui se termine une fois cette Task<TResult> opération terminée ou lorsque le délai d’expiration spécifié expire.

Implémentations d’interfaces explicites

Nom	Description
IAsyncResult.AsyncWaitHandle	Obtient un WaitHandle élément qui peut être utilisé pour attendre la fin de la tâche. (Hérité de Task)
IAsyncResult.CompletedSynchronously	Obtient une indication indiquant si l’opération s’est terminée de façon synchrone. (Hérité de Task)

Méthodes d’extension

Nom	Description
AsAsyncAction(Task)	Retourne une action asynchrone Windows Runtime qui représente une tâche démarrée.
AsAsyncOperation<TResult>(Task<TResult>)	Retourne une opération asynchrone Windows Runtime qui représente une tâche démarrée qui retourne un résultat.
DispatcherOperationWait(Task, TimeSpan)	Attend la fin du délai spécifié pour que le sous-jacent DispatcherOperation se termine.
DispatcherOperationWait(Task)	Attend indéfiniment que le sous-jacent DispatcherOperation se termine.
IsDispatcherOperationTask(Task)	Retourne une valeur qui indique si elle Task est associée à un DispatcherOperation.

S’applique à

Cohérence de thread

Tous les membres de , à l’exception Dispose()de Task<TResult>, sont thread-safe et peuvent être utilisés simultanément à partir de plusieurs threads.

Voir aussi

Commentaires

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