Task<TResult> Classe

Définition

Espace de noms:

System.Threading.Tasks

Assembly:

System.Runtime.dll

Source:

Future.cs

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 cette Task<TResult>.

Héritage

Object

Task

Task<TResult>

Remarques

La classe Task<TResult> représente une seule opération qui retourne une valeur et qui s’exécute généralement de manière asynchrone. Task<TResult> objets sont l’un des composants centraux du modèle asynchrone basé sur des tâches d’abord introduit dans le .NET Framework 4. Étant donné que le travail effectué par un objet Task<TResult> s’exécute 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 propriété Status, ainsi que les propriétés IsCanceled, IsCompletedet IsFaulted, 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> instances peuvent être créées de différentes façons. L’approche la plus courante, disponible à partir du .NET Framework 4.5, consiste à appeler la méthode statique Task.Run<TResult>(Func<TResult>) ou Task.Run<TResult>(Func<TResult>, CancellationToken). 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 méthode Task.Run<TResult>(Func<TResult>) 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 statique TaskFactory.StartNew ou TaskFactory<TResult>.StartNew. La propriété Task.Factory retourne un objet TaskFactory, et la propriété Task<TResult>.Factory retourne un objet TaskFactory<TResult>. Les surcharges de leur méthode StartNew vous permettent de passer des arguments, de définir des options de création de tâches et de spécifier un planificateur de tâches. L’exemple suivant utilise la méthode TaskFactory<TResult>.StartNew(Func<TResult>) 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 des tâches.

La classe Task<TResult> 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 Task.Run et Task.Factory.StartNew 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 Start de 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 les versions du .NET Framework avant .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 rubrique CultureInfo. 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 classe Task. À 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 structure System.Threading.Tasks.ValueTask<TResult>.

Constructeurs

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

Propriétés

AsyncState	Obtient l’objet d’état fourni lorsque l'Task a été créé ou null si aucun n’a été fourni. (Hérité de Task)
CreationOptions	Obtient la TaskCreationOptions utilisée pour créer cette tâche. (Hérité de Task)
Exception	Obtient la AggregateException qui a provoqué la fin prématuré du Task. Si la 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 instances Task<TResult>.
Id	Obtient un ID pour cette instance Task. (Hérité de Task)
IsCanceled	Obtient si cette instance Task 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 le Task terminé en raison d’une exception non gérée. (Hérité de Task)
Result	Obtient la valeur de résultat de cette Task<TResult>.
Status	Obtient la TaskStatus de cette tâche. (Hérité de Task)

Méthodes

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

Implémentations d’interfaces explicites

IAsyncResult.AsyncWaitHandle	Obtient une WaitHandle qui peut être utilisée 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

WaitAsync(Task, TimeSpan, TimeProvider, CancellationToken)	Obtient une Task qui se termine une fois cette Task terminée, lorsque le délai d’expiration spécifié expire ou lorsque le CancellationToken spécifié a demandé l’annulation.
WaitAsync<TResult>(Task<TResult>, TimeSpan, TimeProvider, CancellationToken)	Obtient une Task qui se termine une fois cette Task terminée, lorsque le délai d’expiration spécifié expire ou lorsque le CancellationToken spécifié a demandé l’annulation.

Cohérence de thread

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

Voir aussi

• Task
• bibliothèque parallèle de tâches (TPL)
• programmation asynchrone basée sur des tâches
• exemples de programmation parallèle avec les .NET Core et .NET Standard