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 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 les tâches introduit pour la première fois 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 main, vous pouvez utiliser la Status propriété , ainsi que les IsCanceledpropriétés , IsCompletedet IsFaulted , pour déterminer l’état d’une tâche. Le plus souvent, 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 façons. L’approche la plus courante, disponible à partir de .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 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 statique TaskFactory.StartNew ou TaskFactory<TResult>.StartNew . La Task.Factory propriété renvoie 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âches 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. Elle est fonctionnellement équivalente 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 la planifient pas pour l’exécution. Pour des raisons de performances, les Task.Run méthodes 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 de Start la tâche peut ensuite être utilisée pour planifier la tâche en vue de son exécution ultérieurement.

À compter des applications de bureau qui ciblent le .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 du .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 « Culture et opérations asynchrones basées sur les tâches » dans la CultureInfo rubrique. Notez que les applications du Windows Store suivent les Windows Runtime dans la définition et l’obtention de la culture par défaut.

Pour les opérations qui ne retournent pas de valeur, 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

Task<TResult>(Func<Object,TResult>, Object)	Initialise un nouveau 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 la fonction et les options de création spécifiées.
Task<TResult>(Func<TResult>, TaskCreationOptions)	Initialise une nouvelle Task<TResult> avec la fonction et les options de création spécifiées.

Propriétés

AsyncState	Obtient l'objet d'état fourni quand la Task a été créée, ou null si aucune n'a été fournie. (Hérité de Task)
CreationOptions	Obtient les TaskCreationOptions utilisées pour créer cette tâche. (Hérité de Task)
Exception	Obtient le AggregateException qui a provoqué l'arrêt prématuré de Task. Si la Task s'est terminée avec succès ou n'a pas encore levé d'exception, la valeur null est retournée. (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 instance de Task. (Hérité de Task)
IsCanceled	Indique si cette instance de Task s'est exécutée avec succès suite à une annulation. (Hérité de Task)
IsCompleted	Obtient une valeur indiquant si la tâche est terminée. (Hérité de Task)
IsCompletedSuccessfully	Obtient une valeur indiquant si la tâche s’est exécutée jusqu’à son achèvement. (Hérité de Task)
IsFaulted	Indique si la Task s'est terminée suite à une exception non gérée. (Hérité de Task)
Result	Obtient la valeur de résultat de cette Task<TResult>.
Status	Obtient le TaskStatus de cette tâche. (Hérité de Task)

Méthodes

ConfigureAwait(Boolean)	Configure un élément awaiter utilisé pour attendre cette Task<TResult>.
ConfigureAwait(ConfigureAwaitOptions)	Configure un élément awaiter utilisé pour attendre cette Task.
ContinueWith(Action<Task,Object>, Object)	Crée une continuation qui reçoit des informations d'état fournies par l'appelant et s'exécute quand le Task cible se termine. (Hérité de Task)
ContinueWith(Action<Task,Object>, Object, CancellationToken)	Crée une continuation qui reçoit des informations d'état fournies par l'appelant et un jeton d'annulation, et qui s'exécute de façon asynchrone quand le Task cible se termine. (Hérité de Task)
ContinueWith(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crée une continuation qui reçoit des informations d'état fournies par l'appelant et un jeton d'annulation, et qui s'exécute quand le Task cible se termine. La continuation s'exécute selon 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 des informations d'état fournies par l'appelant et s'exécute quand le Task cible se termine. La continuation s'exécute selon un ensemble de conditions spécifiées. (Hérité de Task)
ContinueWith(Action<Task,Object>, Object, TaskScheduler)	Crée une continuation qui reçoit des informations d'état fournies par l'appelant et s'exécute de façon asynchrone quand le Task cible se termine. La continuation utilise un planificateur spécifié. (Hérité de Task)
ContinueWith(Action<Task<TResult>,Object>, Object)	Crée une continuation à laquelle sont passées des informations d’état et qui s’exécute quand le Task<TResult> cible s’exécute.
ContinueWith(Action<Task<TResult>,Object>, Object, CancellationToken)	Crée une continuation qui s'exécute quand la Task<TResult> cible se termine.
ContinueWith(Action<Task<TResult>,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crée une continuation qui s'exécute quand la Task<TResult> cible se termine.
ContinueWith(Action<Task<TResult>,Object>, Object, TaskContinuationOptions)	Crée une continuation qui s'exécute quand la Task<TResult> cible se termine.
ContinueWith(Action<Task<TResult>,Object>, Object, TaskScheduler)	Crée une continuation qui s'exécute quand la Task<TResult> cible se termine.
ContinueWith(Action<Task<TResult>>)	Crée une continuation qui s’exécute de façon asynchrone quand la tâche cible se termine.
ContinueWith(Action<Task<TResult>>, CancellationToken)	Crée une continuation pouvant être annulée qui s’exécute de façon asynchrone quand la 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 façon asynchrone quand la Task<TResult> cible se termine.
ContinueWith(Action<Task>)	Crée une continuation qui s'exécute de façon asynchrone quand la Task cible se termine. (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 quand le Task cible se termine. (Hérité de Task)
ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crée une continuation qui s’exécute quand la tâche cible se termine conformément au TaskContinuationOptions spécifié. 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 quand la tâche cible se termine conformément au TaskContinuationOptions spécifié. (Hérité de Task)
ContinueWith(Action<Task>, TaskScheduler)	Crée une continuation qui s'exécute de façon asynchrone quand la Task cible se termine. 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 quand la Task<TResult> cible se termine.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, CancellationToken)	Crée une continuation qui s'exécute quand la Task<TResult> cible se termine.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crée une continuation qui s'exécute quand la Task<TResult> cible se termine.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, TaskContinuationOptions)	Crée une continuation qui s'exécute quand la Task<TResult> cible se termine.
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, TaskScheduler)	Crée une continuation qui s'exécute quand la Task<TResult> cible se termine.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>)	Crée une continuation qui s'exécute de façon asynchrone quand la Task<TResult> cible se termine.
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, CancellationToken)	Crée une continuation qui s'exécute de façon asynchrone quand la Task<TResult> cible se termine.
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 façon asynchrone quand la Task<TResult> cible se termine.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object)	Crée une continuation qui reçoit des informations d'état fournies par l'appelant et s'exécute de façon asynchrone quand 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 quand le Task cible se termine et retourne une valeur. La continuation reçoit des 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 quand le Task cible se termine et retourne une valeur. La continuation reçoit des informations d'état fournies par l'appelant et un jeton d'annulation et elle utilise un 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 quand le Task cible se termine. La continuation reçoit des 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 façon asynchrone quand la Task cible se termine. La continuation reçoit des 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 quand 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 quand 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 reçoit 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 quand 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 la 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 élément awaiter utilisé pour attendre cette Task<TResult>.
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)
RunSynchronously()	Exécute de façon synchrone la Task sur le TaskScheduler actuel. (Hérité de Task)
RunSynchronously(TaskScheduler)	Exécute de façon synchrone le Task sur le TaskScheduler fourni. (Hérité de Task)
Start()	Démarre la Task, en planifiant son exécution sur le TaskScheduler actuel. (Hérité de Task)
Start(TaskScheduler)	Démarre la Task, en planifiant son exécution sur le TaskScheduler spécifié. (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 de Task. (Hérité de Task)
Wait(CancellationToken)	Attend la fin de l'exécution de 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)	Attend la fin de l'exécution de la Task en un nombre de millisecondes spécifié. (Hérité de Task)
Wait(Int32, CancellationToken)	Attend la fin de l'exécution de Task. L'attente se termine si un intervalle de délai est écoulé ou si un jeton d'annulation est annulé avant la fin de la tâche. (Hérité de Task)
Wait(TimeSpan)	Attend la fin de l'exécution de la Task dans un intervalle de temps spécifié. (Hérité de Task)
Wait(TimeSpan, CancellationToken)	Attend la fin de l'exécution de Task. (Hérité de Task)
WaitAsync(CancellationToken)	Obtient un Task<TResult> qui se termine à la fin de l’opération Task<TResult> ou lorsque l’annulation demandée est demandée par le spécifié CancellationToken .
WaitAsync(TimeSpan)	Obtient un Task<TResult> qui se termine à la fin de l’opération Task<TResult> ou à l’expiration du délai d’expiration spécifié.
WaitAsync(TimeSpan, CancellationToken)	Obtient un Task<TResult> qui se termine à la fin de cette Task<TResult> opération, lorsque le délai d’expiration spécifié expire ou lorsque l’annulation spécifiée CancellationToken est demandée.
WaitAsync(TimeSpan, TimeProvider)	Obtient un Task<TResult> qui se termine à la fin de l’opération Task<TResult> ou à l’expiration du délai d’expiration spécifié.
WaitAsync(TimeSpan, TimeProvider, CancellationToken)	Obtient un Task<TResult> qui se termine à la fin de cette Task<TResult> opération, lorsque le délai d’expiration spécifié expire ou lorsque l’annulation spécifiée CancellationToken est demandée.

Implémentations d’interfaces explicites

IAsyncResult.AsyncWaitHandle	Obtient un WaitHandle qui peut être utilisé en attendant la fin de la tâche. (Hérité de Task)
IAsyncResult.CompletedSynchronously	Obtient une indication précisant si l’opération s’est terminée de manière synchrone. (Hérité de Task)

Méthodes d’extension

WaitAsync(Task, TimeSpan, TimeProvider, CancellationToken)	Représente une opération asynchrone qui peut retourner une valeur.
WaitAsync<TResult>(Task<TResult>, TimeSpan, TimeProvider, CancellationToken)	Représente une opération asynchrone qui peut retourner une valeur.

Cohérence de thread

Tous les membres de , à l’exception de Task<TResult>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
• Programmation asynchrone basée sur les tâches
• Exemples de programmation parallèle avec .NET Core et .NET Standard