task (Concurrency Runtime), classe

Classe task de la bibliothèque de modèles parallèles (PPL, Parallel Patterns Library). Un task objet représente le travail qui peut être exécuté de manière asynchrone et simultanée avec d’autres tâches et travaux parallèles générés par des algorithmes parallèles dans le runtime d’accès concurrentiel. Il génère un résultat de type _ResultType quand il s'exécute correctement. Les tâches de type task<void> ne génèrent aucun résultat. Une tâche peut être mise en attente et annulée indépendamment des autres tâches. Il peut également être composé avec d’autres tâches à l’aide de continuations( then), et de jointure( when_all) et de modèles de choix( when_any). Lorsqu’un objet de tâche est affecté à une nouvelle variable, le comportement est celui de std::shared_ptr; en d’autres termes, les deux objets représentent la même tâche sous-jacente.

Syntaxe

template <>
class task<void>;

template<typename _ResultType>
class task;

Paramètres

_ResultType
Type du résultat produit par la tâche.

Membres

Typedefs publics

Constructeurs publics

Méthodes publiques

Opérateurs publics

Notes

Pour plus d’informations, consultez Parallélisme des tâches.

Hiérarchie d'héritage

task

Spécifications

En-tête : ppltasks.h

Espace de noms : concurrency

get

Retourne le résultat produit par cette tâche. Si la tâche n’est pas dans un état terminal, un appel à get attendra que la tâche se termine. Cette méthode ne retourne pas de valeur lorsqu’elle est appelée sur une tâche dont le result_type a la valeur void.

_ResultType get() const;

void get() const;

Valeur de retour

Résultat de la tâche.

Notes

Si la tâche est annulée, un appel à get levera une exception task_canceled . Si la tâche rencontre une exception différente ou si une exception est propagée à cette tâche à partir d'une tâche précédente, un appel à get lève cette exception.

is_apartment_aware

Détermine si la tâche désencapsule une interface IAsyncInfo Windows Runtime ou descend de cette tâche.

bool is_apartment_aware() const;

Valeur de retour

true si la tâche supprime une IAsyncInfo interface ou est décroissante d’une telle tâche, false sinon.

task ::is_done, méthode (runtime d’accès concurrentiel)

Détermine si la tâche est terminée.

bool is_done() const;

Valeur de retour

True si la tâche est terminée, false dans le cas contraire.

Notes

La fonction retourne true si la tâche est terminée ou annulée (avec ou sans exception utilisateur).

operator!=

Détermine si deux objets task représentent différentes tâches internes.

bool operator!= (const task<_ResultType>& _Rhs) const;

bool operator!= (const task<void>& _Rhs) const;

Paramètres

_Rhs
Tâche à comparer.

Valeur de retour

true si les objets font référence à différentes tâches sous-jacentes et false sinon.

opérateur =

Remplace le contenu d'un objet task par un autre.

task& operator= (const task& _Other);

task& operator= (task&& _Other);

Paramètres

_Autre
Objet task source.

Valeur de retour

Notes

Étant donné que task se comporte comme un pointeur intelligent, après une assignation de copie, cet objet task représente la même tâche réelle que _Other.

operator==

Détermine si deux objets task représentent la même tâche interne.

bool operator== (const task<_ResultType>& _Rhs) const;

bool operator== (const task<void>& _Rhs) const;

Paramètres

_Rhs
Tâche à comparer.

Valeur de retour

true si les objets font référence à la même tâche sous-jacente et false sinon.

task ::scheduler, méthode (runtime d’accès concurrentiel)

Retourne le planificateur pour cette tâche.

scheduler_ptr scheduler() const;

Valeur de retour

Pointeur vers le planificateur

tâche

Construit un objet task.

task();

template<typename T>
__declspec(
    noinline) explicit task(T _Param);

template<typename T>
__declspec(
    noinline) explicit task(T _Param, const task_options& _TaskOptions);

task(
    const task& _Other);

task(
    task&& _Other);

Paramètres

T
Type du paramètre à partir duquel la tâche doit être construite.

_Param
Paramètre à partir duquel la tâche doit être construite. Il peut s’agir d’un objet lambda, d’un task_completion_event<result_type> objet de fonction ou d’un Windows ::Foundation ::IAsyncInfo si vous utilisez des tâches dans votre application Windows Runtime. L’objet lambda ou de fonction doit être un type équivalent à std::function<X(void)>, où X peut être une variable de type result_type, task<result_type>ou un Windows ::Foundation ::IAsyncInfo dans les applications Windows Runtime.

_TaskOptions
Les options de tâche incluent le jeton d’annulation, le planificateur, etc.

_Autre
Objet task source.

Notes

Le constructeur par défaut pour task est uniquement présent pour permettre l’utilisation des tâches dans des conteneurs. Une tâche créée par défaut ne peut pas être utilisée tant que vous ne lui assignez pas une tâche valide. Les méthodes telles que get, wait ou then lèvent une exception invalid_argument lorsqu’elles sont appelées sur une tâche construite par défaut.

Une tâche créée à partir d’un objet task_completion_event s’achève (et ses continuations sont planifiées) lorsque l’événement d’achèvement de tâche est défini.

La version du constructeur qui accepte un jeton d’annulation crée une tâche qui peut être annulée en utilisant la classe cancellation_token_source à partir de laquelle le jeton a été obtenu. Les tâches créées sans jeton d'annulation ne sont pas annulables.

Les tâches créées à partir d’une interface Windows::Foundation::IAsyncInfo ou d’une expression lambda qui retourne une interface IAsyncInfo atteignent leur état terminal lorsque l’opération ou l’action asynchrone Windows Runtime se termine. De même, les tâches créées à partir d’une lambda qui retourne un task<result_type> état terminal atteint l’état du terminal lorsque la tâche interne atteint son état terminal, et non lorsque l’expression lambda retourne.

task se comporte comme un pointeur intelligent dont le passage par valeur est sécurisé. Il est accessible par plusieurs threads sans nécessiter de verrous.

Les surcharges de constructeur qui prennent une interface Windows ::Foundation ::IAsyncInfo ou une interface lambda retournant une telle interface ne sont disponibles que pour les applications Windows Runtime.

Pour plus d’informations, consultez Parallélisme des tâches.

, puis

Ajoute une tâche de continuation à cette tâche.

template<typename _Function>
__declspec(
    noinline) auto then(const _Function& _Func) const -> typename details::_ContinuationTypeTraits<_Function,
    _ResultType>::_TaskOfType;

template<typename _Function>
__declspec(
    noinline) auto then(const _Function& _Func,
    const task_options& _TaskOptions) const -> typename details::_ContinuationTypeTraits<_Function,
    _ResultType>::_TaskOfType;

template<typename _Function>
__declspec(
    noinline) auto then(const _Function& _Func,
    cancellation_token _CancellationToken,
    task_continuation_context _ContinuationContext) const -> typename details::_ContinuationTypeTraits<_Function,
    _ResultType>::_TaskOfType;

template<typename _Function>
__declspec(
    noinline) auto then(const _Function& _Func,
    const task_options& _TaskOptions = task_options()) const -> typename details::_ContinuationTypeTraits<_Function,
    void>::_TaskOfType;

template<typename _Function>
__declspec(
    noinline) auto then(const _Function& _Func,
    cancellation_token _CancellationToken,
    task_continuation_context _ContinuationContext) const -> typename details::_ContinuationTypeTraits<_Function,
    void>::_TaskOfType;

Paramètres

_Fonction
Type de l’objet fonction qui sera appelé par cette tâche.

_Func
Fonction de continuation à exécuter lorsque cette tâche se termine. Cette fonction de continuation doit accepter comme entrée une variable result_type ou task<result_type>, où result_type correspond au type du résultat produit par cette tâche.

_TaskOptions
Les options de la tâche incluent le jeton d'annulation, le planificateur et le contexte de continuation. Par défaut, les 3 options précédentes sont héritées de la tâche précédente.

_CancellationToken
Jeton d'annulation à associer à la tâche de continuation. Une tâche de continuation créée sans jeton d‘annulation hérite du jeton de son antécédent.

_ContinuationContext
Variable qui spécifie où la continuation doit s'exécuter. Cette variable est utile uniquement lorsqu’elle est utilisée dans une application UWP. Pour plus d’informations, consultez task_continuation_context

Valeur de retour

Tâche de continuation récemment créée. Le type de résultat de la tâche retournée est déterminé par l’élément retourné par _Func.

Notes

Les surcharges qui then prennent un fonctor ou lambda qui retourne une interface Windows ::Foundation ::IAsyncInfo, sont uniquement disponibles pour les applications Windows Runtime.

Pour plus d’informations sur l’utilisation des continuations de tâches pour composer un travail asynchrone, consultez Le parallélisme des tâches.

wait

Attend que cette tâche atteigne un état terminal. Il est possible que wait exécute la tâche inline si toutes les dépendances de tâches sont remplies et si elle n’a pas déjà été sélectionnée pour être exécutée par un processus de travail d’arrière-plan.

task_status wait() const;

Valeur de retour

Valeur task_status qui peut être completed ou canceled. Si la tâche rencontre une exception pendant l‘exécution, ou si une exception y est propagée à partir d‘une tâche précédente, wait lèvera cette exception.

Notes

Voir aussi

accès concurrentiel Namespace