Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

Task<TResult> classe

 

Date de publication : novembre 2016

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

Espace de noms:   System.Threading.Tasks
Assembly:  mscorlib (dans mscorlib.dll)

System.Object
  System.Threading.Tasks.Task
    System.Threading.Tasks.Task<TResult>

[HostProtectionAttribute(SecurityAction.LinkDemand, Synchronization = true, 
	ExternalThreading = true)]
public class Task<TResult> : Task

Paramètres de type

TResult

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

NomDescription
System_CAPS_pubmethodTask<TResult>(Func<TResult>)

Initialise une nouvelle Task<TResult> avec la fonction spécifiée.

System_CAPS_pubmethodTask<TResult>(Func<TResult>, CancellationToken)

Initialise une nouvelle Task<TResult> avec la fonction spécifiée.

System_CAPS_pubmethodTask<TResult>(Func<TResult>, CancellationToken, TaskCreationOptions)

Initialise une nouvelle Task<TResult> avec la fonction et les options de création spécifiées.

System_CAPS_pubmethodTask<TResult>(Func<TResult>, TaskCreationOptions)

Initialise une nouvelle Task<TResult> avec la fonction et les options de création spécifiées.

System_CAPS_pubmethodTask<TResult>(Func<Object, TResult>, Object)

Initialise un nouveau Task<TResult> avec la fonction et l'état spécifiés.

System_CAPS_pubmethodTask<TResult>(Func<Object, TResult>, Object, CancellationToken)

Initialise une nouvelle Task<TResult> avec l'action, l'état et les options spécifiés.

System_CAPS_pubmethodTask<TResult>(Func<Object, TResult>, Object, CancellationToken, TaskCreationOptions)

Initialise une nouvelle Task<TResult> avec l'action, l'état et les options spécifiés.

System_CAPS_pubmethodTask<TResult>(Func<Object, TResult>, Object, TaskCreationOptions)

Initialise une nouvelle Task<TResult> avec l'action, l'état et les options spécifiés.

NomDescription
System_CAPS_pubpropertyAsyncState

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.)

System_CAPS_pubpropertyCreationOptions

Obtient les TaskCreationOptions utilisées pour créer cette tâche.(Hérité de Task.)

System_CAPS_pubpropertyException

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.)

System_CAPS_pubpropertySystem_CAPS_staticFactory

Fournit l'accès aux méthodes de fabrique pour la création et la configuration d'instances de Task<TResult>.

System_CAPS_pubpropertyId

Obtient un ID pour cette instance de Task.(Hérité de Task.)

System_CAPS_pubpropertyIsCanceled

Indique si cette instance de Task s'est exécutée avec succès suite à une annulation.(Hérité de Task.)

System_CAPS_pubpropertyIsCompleted

Indique si cette Task s'est terminée.(Hérité de Task.)

System_CAPS_pubpropertyIsFaulted

Indique si la Task s'est terminée suite à une exception non gérée.(Hérité de Task.)

System_CAPS_pubpropertyResult

Obtient la valeur de résultat de cette Task<TResult>.

System_CAPS_pubpropertyStatus

Obtient le TaskStatus de cette tâche.(Hérité de Task.)

NomDescription
System_CAPS_pubmethodConfigureAwait(Boolean)

Configure un élément awaiter utilisé pour attendre cette Task<TResult>.

System_CAPS_pubmethodContinueWith(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.)

System_CAPS_pubmethodContinueWith(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.)

System_CAPS_pubmethodContinueWith(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.)

System_CAPS_pubmethodContinueWith(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.)

System_CAPS_pubmethodContinueWith(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.)

System_CAPS_pubmethodContinueWith(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 se termine.

System_CAPS_pubmethodContinueWith(Action<Task<TResult>, Object>, Object, CancellationToken)

Crée une continuation qui s'exécute quand la Task<TResult> cible se termine.

System_CAPS_pubmethodContinueWith(Action<Task<TResult>, Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)

Crée une continuation qui s'exécute quand la Task<TResult> cible se termine.

System_CAPS_pubmethodContinueWith(Action<Task<TResult>, Object>, Object, TaskContinuationOptions)

Crée une continuation qui s'exécute quand la Task<TResult> cible se termine.

System_CAPS_pubmethodContinueWith(Action<Task<TResult>, Object>, Object, TaskScheduler)

Crée une continuation qui s'exécute quand la Task<TResult> cible se termine.

System_CAPS_pubmethodContinueWith(Action<Task<TResult>>)

Crée une continuation qui s’exécute de façon asynchrone quand la tâche cible se termine.

System_CAPS_pubmethodContinueWith(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.

System_CAPS_pubmethodContinueWith(Action<Task<TResult>>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Crée une continuation qui s'exécute en fonction de la condition spécifiée dans continuationOptions.

System_CAPS_pubmethodContinueWith(Action<Task<TResult>>, TaskContinuationOptions)

Crée une continuation qui s'exécute en fonction de la condition spécifiée dans continuationOptions.

System_CAPS_pubmethodContinueWith(Action<Task<TResult>>, TaskScheduler)

Crée une continuation qui s'exécute de façon asynchrone quand la Task<TResult> cible se termine.

System_CAPS_pubmethodContinueWith(Action<Task>)

Crée une continuation qui s'exécute de façon asynchrone quand la Task cible se termine.(Hérité de Task.)

System_CAPS_pubmethodContinueWith(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.)

System_CAPS_pubmethodContinueWith(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.)

System_CAPS_pubmethodContinueWith(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.)

System_CAPS_pubmethodContinueWith(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.)

System_CAPS_pubmethodContinueWith<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.)

System_CAPS_pubmethodContinueWith<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.)

System_CAPS_pubmethodContinueWith<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.)

System_CAPS_pubmethodContinueWith<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.)

System_CAPS_pubmethodContinueWith<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.)

System_CAPS_pubmethodContinueWith<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.)

System_CAPS_pubmethodContinueWith<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.)

System_CAPS_pubmethodContinueWith<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.)

System_CAPS_pubmethodContinueWith<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 et retourne une valeur. La continuation reçoit des informations d'état fournies par l'appelant.(Hérité de Task.)

System_CAPS_pubmethodContinueWith<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.)

System_CAPS_pubmethodContinueWith<TNewResult>(Func<Task<TResult>, TNewResult>)

Crée une continuation qui s'exécute de façon asynchrone quand la Task<TResult> cible se termine.

System_CAPS_pubmethodContinueWith<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.

System_CAPS_pubmethodContinueWith<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.

System_CAPS_pubmethodContinueWith<TNewResult>(Func<Task<TResult>, TNewResult>, TaskContinuationOptions)

Crée une continuation qui s'exécute en fonction de la condition spécifiée dans continuationOptions.

System_CAPS_pubmethodContinueWith<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.

System_CAPS_pubmethodContinueWith<TNewResult>(Func<Task<TResult>, Object, TNewResult>, Object)

Crée une continuation qui s'exécute quand la Task<TResult> cible se termine.

System_CAPS_pubmethodContinueWith<TNewResult>(Func<Task<TResult>, Object, TNewResult>, Object, CancellationToken)

Crée une continuation qui s'exécute quand la Task<TResult> cible se termine.

System_CAPS_pubmethodContinueWith<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.

System_CAPS_pubmethodContinueWith<TNewResult>(Func<Task<TResult>, Object, TNewResult>, Object, TaskContinuationOptions)

Crée une continuation qui s'exécute quand la Task<TResult> cible se termine.

System_CAPS_pubmethodContinueWith<TNewResult>(Func<Task<TResult>, Object, TNewResult>, Object, TaskScheduler)

Crée une continuation qui s'exécute quand la Task<TResult> cible se termine.

System_CAPS_pubmethodDispose()

Libère toutes les ressources utilisées par l'instance actuelle de la classe Task.(Hérité de Task.)

System_CAPS_protmethodDispose(Boolean)

Supprime la Task, en libérant toutes ses ressources non managées.(Hérité de Task.)

System_CAPS_pubmethodEquals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.(Hérité de Object.)

System_CAPS_protmethodFinalize()

Autorise un objet à tenter de libérer des ressources et à exécuter d'autres opérations de nettoyage avant qu'il ne soit récupéré par une opération garbage collection.(Hérité de Object.)

System_CAPS_pubmethodGetAwaiter()

Obtient un élément awaiter utilisé pour attendre cette Task<TResult>.

System_CAPS_pubmethodGetHashCode()

Fait office de fonction de hachage par défaut.(Hérité de Object.)

System_CAPS_pubmethodGetType()

Obtient le Type de l'instance actuelle.(Hérité de Object.)

System_CAPS_protmethodMemberwiseClone()

Crée une copie superficielle du Object actuel.(Hérité de Object.)

System_CAPS_pubmethodRunSynchronously()

Exécute de façon synchrone la Task sur le TaskScheduler actuel.(Hérité de Task.)

System_CAPS_pubmethodRunSynchronously(TaskScheduler)

Exécute de façon synchrone le Task sur le TaskScheduler fourni.(Hérité de Task.)

System_CAPS_pubmethodStart()

Démarre la Task, en planifiant son exécution selon le TaskScheduler actuel.(Hérité de Task.)

System_CAPS_pubmethodStart(TaskScheduler)

Démarre la Task, en planifiant son exécution sur le TaskScheduler spécifié.(Hérité de Task.)

System_CAPS_pubmethodToString()

Retourne une chaîne qui représente l'objet actuel.(Hérité de Object.)

System_CAPS_pubmethodWait()

Attend la fin de l'exécution de Task.(Hérité de Task.)

System_CAPS_pubmethodWait(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.)

System_CAPS_pubmethodWait(Int32)

Attend la fin de l'exécution de la Task en un nombre de millisecondes spécifié.(Hérité de Task.)

System_CAPS_pubmethodWait(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.)

System_CAPS_pubmethodWait(TimeSpan)

Attend la fin de l'exécution de la Task dans un intervalle de temps spécifié.(Hérité de Task.)

NomDescription
System_CAPS_pubinterfaceSystem_CAPS_privpropertyIAsyncResult.AsyncWaitHandle

Obtient un WaitHandle qui peut être utilisé en attendant la fin de la tâche.(Hérité de Task.)

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIAsyncResult.CompletedSynchronously

Obtient une indication précisant si l’opération s’est terminée de manière synchrone.(Hérité de Task.)

NomDescription
System_CAPS_pubmethodDispatcherOperationWait()

Surchargé. Attend indéfiniment sous-jacent DispatcherOperation pour terminer.(Défini par TaskExtensions.)

System_CAPS_pubmethodDispatcherOperationWait(TimeSpan)

Surchargé. Attend que le laps de temps pour sous-jacent DispatcherOperation pour terminer.(Défini par TaskExtensions.)

System_CAPS_pubmethodIsDispatcherOperationTask()

Retourne une valeur qui indique si cette Task est associé à un DispatcherOperation.(Défini par TaskExtensions.)

La Task<TResult> classe représente une opération unique qui retourne une valeur et qui généralement exécute de façon asynchrone. Task<TResult> les objets sont parmi les composants centraux du premier introduite dans .NET Framework 4. Étant donné que le travail effectué par un Task<TResult> objet généralement exécute de façon asynchrone sur un thread de pool de threads plutôt que de façon synchrone sur le thread d’application principal, vous pouvez utiliser le Status propriété, ainsi que le IsCanceled, IsCompleted, et IsFaulted Propriétés, pour déterminer l’état d’une tâche. En règle générale, une expression lambda est utilisée pour spécifier le travail à effectuer la tâche.

Task<TResult> instances peuvent être créées de plusieurs façons. L’approche la plus courante, qui est 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) (méthode). Ces méthodes fournissent un moyen simple pour démarrer une tâche à l’aide des valeurs par défaut et sans acquérir des paramètres supplémentaires. L’exemple suivant utilise le Task.Run<TResult>(Func<TResult>) méthode pour lancer 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.

Une alternative et la méthode la plus courante pour démarrer une tâche dans le .NET Framework 4, consiste à appeler la méthode statique TaskFactory.StartNew ou TaskFactory<TResult>.StartNew (méthode). Le Task.Factory propriété retourne un TaskFactory objet et le Task<TResult>.Factory propriété retourne un TaskFactory<TResult> objet. Les surcharges de leur StartNew méthode vous permettre de passer des arguments, définir des options de création de tâche et spécifier un planificateur de tâches. L’exemple suivant utilise le TaskFactory<TResult>.StartNew(Func<TResult>) méthode pour démarrer une tâche. Il est fonctionnellement équivalent au code dans 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

Pour des exemples plus complets, consultez Task Parallelism (Task Parallel Library).

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, le Task.Run et StartNew méthodes sont le mécanisme préféré pour créer et planifier des tâches de calcul, mais pour les scénarios où la création de tâches et la planification doivent être séparés, les constructeurs peuvent être utilisés et de la tâche Start méthode peut ensuite être utilisée pour planifier la tâche pour l’exécution à un moment ultérieur.

Démarrage avec les applications de bureau qui ciblent le .NET Framework 4.6, la culture du thread qui crée et appelle une tâche devient partie intégrante du contexte du thread. Autrement dit, indépendamment de la culture actuelle du thread sur lequel la tâche s’exécute, la culture en cours de la tâche est la culture du thread appelant. Pour les applications qui ciblent des versions du .NET Framework antérieures à la .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 une tâche » dans la CultureInfo rubrique. Notez que les applications du Windows Store suivent le 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, vous utilisez la Task classe.

Plateforme Windows universelle
Disponible depuis 8
.NET Framework
Disponible depuis 4.0
Bibliothèque de classes portable
Pris en charge dans : plateformes .NET portables
Silverlight
Disponible depuis 5.0
Silverlight pour Windows Phone
Disponible depuis 8.0
Windows Phone
Disponible depuis 8.1

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

Retour au début
Afficher: