task (Concurrency Runtime), classetask Class (Concurrency Runtime)

Classe task de la bibliothèque de modèles parallèles (PPL, Parallel Patterns Library).The Parallel Patterns Library (PPL) task class. Un task objet représente le travail qui peut être exécuté de façon asynchrone et simultanément avec d’autres tâches et le travail parallèle produit par des algorithmes parallèles dans la Runtime d’accès concurrentiel.A task object represents work that can be executed asynchronously and concurrently with other tasks and parallel work produced by parallel algorithms in the Concurrency Runtime. Il génère un résultat de type _ResultType quand il s'exécute correctement.It produces a result of type _ResultType on successful completion. Les tâches de type task<void> ne génèrent aucun résultat.Tasks of type task<void> produce no result. Une tâche peut être mise en attente et annulée indépendamment des autres tâches.A task can be waited upon and canceled independently of other tasks. Elle peut également être composée avec d’autres tâches à l’aide de continuations () et de then modèles de jointure () when_all et de choix ( when_any ).It can also be composed with other tasks using continuations( then), and join( when_all) and choice( when_any) patterns. Lorsqu’un objet de tâche est assigné à 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.When a task object is assigned to a new variable, the behavior is that of std::shared_ptr; in other words, both objects represent the same underlying task.

SyntaxeSyntax

template <>
class task<void>;

template<typename _ResultType>
class task;

ParamètresParameters

_ResultType_ResultType
Type du résultat produit par la tâche.The type of the result that the task produces.

MembresMembers

Typedefs publicsPublic Typedefs

NomName DescriptionDescription
result_type Type de résultat produit par un objet de cette classe.The type of the result an object of this class produces.

Constructeurs publicsPublic Constructors

NomName DescriptionDescription
tâchetask Surchargé.Overloaded. Construit un objet task.Constructs a task object.

Méthodes publiquesPublic Methods

NomName DescriptionDescription
getget Surchargé.Overloaded. Retourne le résultat produit par cette tâche.Returns the result this task produced. Si la tâche n’est pas dans un état terminal, un appel à get attendra que la tâche se termine.If the task is not in a terminal state, a call to get will wait for the task to finish. Cette méthode ne retourne pas de valeur lorsqu’elle est appelée sur une tâche avec un result_type de void .This method does not return a value when called on a task with a result_type of void.
is_apartment_awareis_apartment_aware Détermine si la tâche désencapsule une interface IAsyncInfo Windows Runtime ou descend de cette tâche.Determines whether the task unwraps a Windows Runtime IAsyncInfo interface or is descended from such a task.
is_doneis_done Détermine si la tâche est terminée.Determines if the task is completed.
planificateurscheduler Retourne le planificateur pour cette tâche.Returns the scheduler for this task
Cliquezthen Surchargé.Overloaded. Ajoute une tâche de continuation à cette tâche.Adds a continuation task to this task.
qu'wait Attend que cette tâche atteigne un état terminal.Waits for this task to reach a terminal state. 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.It is possible for wait to execute the task inline, if all of the tasks dependencies are satisfied, and it has not already been picked up for execution by a background worker.

Opérateurs publicsPublic Operators

NomName DescriptionDescription
opérateur ! =operator!= Surchargé.Overloaded. Détermine si deux objets task représentent différentes tâches internes.Determines whether two task objects represent different internal tasks.
opérateur =operator= Surchargé.Overloaded. Remplace le contenu d'un objet task par un autre.Replaces the contents of one task object with another.
opérateur = =operator== Surchargé.Overloaded. Détermine si deux objets task représentent la même tâche interne.Determines whether two task objects represent the same internal task.

NotesRemarks

Pour plus d’informations, consultez parallélisme des tâches.For more information, see Task Parallelism.

Hiérarchie d'héritageInheritance Hierarchy

task

SpécificationsRequirements

En-tête : ppltasks. hHeader: ppltasks.h

Espace de noms : concurrenceNamespace: concurrency

Téléchargerget

Retourne le résultat produit par cette tâche.Returns the result this task produced. Si la tâche n’est pas dans un état terminal, un appel à get attendra que la tâche se termine.If the task is not in a terminal state, a call to get will wait for the task to finish. Cette méthode ne retourne pas de valeur lorsqu’elle est appelée sur une tâche avec un result_type de void .This method does not return a value when called on a task with a result_type of void.

_ResultType get() const;

void get() const;

Valeur de retourReturn Value

Résultat de la tâche.The result of the task.

NotesRemarks

Si la tâche est annulée, un appel à get lève une exception task_canceled .If the task is canceled, a call to get will throw a task_canceled exception. 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.If the task encountered an different exception or an exception was propagated to it from an antecedent task, a call to get will throw that exception.

Important

Dans une application plateforme Windows universelle (UWP), n’appelez pas Concurrency :: Task :: wait ou get ( wait Calls get ) dans le code qui s’exécute sur le thread d’interface utilisateur.In a Universal Windows Platform (UWP) app, do not call concurrency::task::wait or get ( wait calls get) in code that runs on the user-interface thread. Sinon, le runtime lève Concurrency :: invalid_operation , car ces méthodes bloquent le thread actuel et peuvent provoquer le blocage de l’application.Otherwise, the runtime throws concurrency::invalid_operation because these methods block the current thread and can cause the app to become unresponsive. Toutefois, vous pouvez appeler la get méthode pour recevoir le résultat de la tâche antécédente dans une continuation basée sur des tâches, car le résultat est immédiatement disponible.However, you can call the get method to receive the result of the antecedent task in a task-based continuation because the result is immediately available.

is_apartment_awareis_apartment_aware

Détermine si la tâche désencapsule une interface IAsyncInfo Windows Runtime ou descend de cette tâche.Determines whether the task unwraps a Windows Runtime IAsyncInfo interface or is descended from such a task.

bool is_apartment_aware() const;

Valeur de retourReturn Value

true Si la tâche désencapsule une IAsyncInfo interface ou est décroisée d’une telle tâche, false sinon.true if the task unwraps an IAsyncInfo interface or is descended from such a task, false otherwise.

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

Détermine si la tâche est terminée.Determines if the task is completed.

bool is_done() const;

Valeur de retourReturn Value

True si la tâche est terminée ; sinon, false.True if the task has completed, false otherwise.

NotesRemarks

La fonction retourne la valeur true si la tâche est terminée ou annulée (avec ou sans exception utilisateur).The function returns true if the task is completed or canceled (with or without user exception).

opérateur ! =operator!=

Détermine si deux objets task représentent différentes tâches internes.Determines whether two task objects represent different internal tasks.

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

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

ParamètresParameters

_Rhs_Rhs
Tâche à comparer.The task to compare.

Valeur de retourReturn Value

true Si les objets font référence à différentes tâches sous-jacentes, et dans le false cas contraire.true if the objects refer to different underlying tasks, and false otherwise.

opérateur =operator=

Remplace le contenu d'un objet task par un autre.Replaces the contents of one task object with another.

task& operator= (const task& _Other);

task& operator= (task&& _Other);

ParamètresParameters

_Other_Other
Objet task source.The source task object.

Valeur de retourReturn Value

NotesRemarks

É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.As task behaves like a smart pointer, after a copy assignment, this task objects represents the same actual task as _Other does.

opérateur = =operator==

Détermine si deux objets task représentent la même tâche interne.Determines whether two task objects represent the same internal task.

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

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

ParamètresParameters

_Rhs_Rhs
Tâche à comparer.The task to compare.

Valeur de retourReturn Value

true Si les objets font référence à la même tâche sous-jacente, et dans le false cas contraire.true if the objects refer to the same underlying task, and false otherwise.

Task :: Scheduler, méthode (runtime d’accès concurrentiel)task::scheduler Method (Concurrency Runtime)

Retourne le planificateur pour cette tâche.Returns the scheduler for this task

scheduler_ptr scheduler() const;

Valeur de retourReturn Value

Pointeur vers le planificateurA pointer to the scheduler

Tâche task

Construit un objet task.Constructs a task object.

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ètresParameters

TT
Type du paramètre à partir duquel la tâche doit être construite.The type of the parameter from which the task is to be constructed.

_Param_Param
Paramètre à partir duquel la tâche doit être construite.The parameter from which the task is to be constructed. Il peut s’agir d’une expression lambda, d’un objet de fonction, d’un task_completion_event<result_type> objet ou de Windows :: Foundation :: IAsyncInfo si vous utilisez des tâches dans votre application Windows Runtime.This could be a lambda, a function object, a task_completion_event<result_type> object, or a Windows::Foundation::IAsyncInfo if you are using tasks in your Windows Runtime app. L’expression lambda ou l’objet 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.The lambda or function object should be a type equivalent to std::function<X(void)>, where X can be a variable of type result_type, task<result_type>, or a Windows::Foundation::IAsyncInfo in Windows Runtime apps.

_TaskOptions_TaskOptions
Les options de tâche incluent le jeton d’annulation, le planificateur, etc.The task options include cancellation token, scheduler etc

_Other_Other
Objet task source.The source task object.

NotesRemarks

Le constructeur par défaut pour task est uniquement présent pour permettre l’utilisation des tâches dans des conteneurs.The default constructor for a task is only present in order to allow tasks to be used within containers. 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.A default constructed task cannot be used until you assign a valid task to it. Les méthodes telles que get , wait ou then lèveront une exception invalid_argument lorsqu’elles sont appelées sur une tâche construite par défaut.Methods such as get, wait or then will throw an invalid_argument exception when called on a default constructed task.

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.A task that is created from a task_completion_event will complete (and have its continuations scheduled) when the task completion event is set.

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.The version of the constructor that takes a cancellation token creates a task that can be canceled using the cancellation_token_source the token was obtained from. Les tâches créées sans jeton d'annulation ne sont pas annulables.Tasks created without a cancellation token are not cancelable.

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.Tasks created from a Windows::Foundation::IAsyncInfo interface or a lambda that returns an IAsyncInfo interface reach their terminal state when the enclosed Windows Runtime asynchronous operation or action completes. De même, les tâches créées à partir d’une expression lambda qui retourne un task<result_type> atteignent leur état terminal lorsque la tâche interne atteint son état terminal, et non lorsque l’expression lambda retourne une valeur.Similarly, tasks created from a lambda that returns a task<result_type> reach their terminal state when the inner task reaches its terminal state, and not when the lambda returns.

task se comporte comme un pointeur intelligent dont le passage par valeur est sécurisé.task behaves like a smart pointer and is safe to pass around by value. Il est accessible par plusieurs threads sans nécessiter de verrous.It can be accessed by multiple threads without the need for locks.

Les surcharges de constructeur qui acceptent une interface Windows :: Foundation :: IAsyncInfo ou une expression lambda retournant une telle interface sont uniquement disponibles pour les applications Windows Runtime.The constructor overloads that take a Windows::Foundation::IAsyncInfo interface or a lambda returning such an interface, are only available to Windows Runtime apps.

Pour plus d’informations, consultez parallélisme des tâches.For more information, see Task Parallelism.

Cliquezthen

Ajoute une tâche de continuation à cette tâche.Adds a continuation task to this task.

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ètresParameters

_Function_Function
Type de l’objet fonction qui sera appelé par cette tâche.The type of the function object that will be invoked by this task.

_Func_Func
Fonction de continuation à exécuter lorsque cette tâche se termine.The continuation function to execute when this task completes. 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.This continuation function must take as input a variable of either result_type or task<result_type>, where result_type is the type of the result this task produces.

_TaskOptions_TaskOptions
Les options de la tâche incluent le jeton d'annulation, le planificateur et le contexte de continuation.The task options include cancellation token, scheduler and continuation context. Par défaut, les 3 options précédentes sont héritées de la tâche précédente.By default the former 3 options are inherited from the antecedent task

_CancellationToken_CancellationToken
Jeton d'annulation à associer à la tâche de continuation.The cancellation token to associate with the continuation task. Une tâche de continuation créée sans jeton d‘annulation hérite du jeton de son antécédent.A continuation task that is created without a cancellation token will inherit the token of its antecedent task.

_ContinuationContext_ContinuationContext
Variable qui spécifie où la continuation doit s'exécuter.A variable that specifies where the continuation should execute. Cette variable est utile uniquement lorsqu’elle est utilisée dans une application UWP.This variable is only useful when used in a UWP app. Pour plus d’informations, consultez task_continuation_contextFor more information, see task_continuation_context

Valeur de retourReturn Value

Tâche de continuation récemment créée.The newly created continuation task. Le type de résultat de la tâche retournée est déterminé par l’élément retourné par _Func.The result type of the returned task is determined by what _Func returns.

NotesRemarks

Les surcharges de then qui acceptent une expression lambda ou functor qui retourne une interface Windows :: Foundation :: IAsyncInfo sont uniquement disponibles pour les applications Windows Runtime.The overloads of then that take a lambda or functor that returns a Windows::Foundation::IAsyncInfo interface, are only available to Windows Runtime apps.

Pour plus d’informations sur l’utilisation des continuations de tâches pour composer un travail asynchrone, consultez parallélisme des tâches.For more information on how to use task continuations to compose asynchronous work, see Task Parallelism.

qu'wait

Attend que cette tâche atteigne un état terminal.Waits for this task to reach a terminal state. 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.It is possible for wait to execute the task inline, if all of the tasks dependencies are satisfied, and it has not already been picked up for execution by a background worker.

task_status wait() const;

Valeur de retourReturn Value

Valeur task_status qui peut être completed ou canceled.A task_status value which could be either completed or 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.If the task encountered an exception during execution, or an exception was propagated to it from an antecedent task, wait will throw that exception.

NotesRemarks

Important

Dans une application plateforme Windows universelle (UWP), n’appelez pas wait dans le code qui s’exécute sur le thread d’interface utilisateur.In a Universal Windows Platform (UWP) app, do not call wait in code that runs on the user-interface thread. Sinon, le runtime lève concurrency::invalid_operation , car cette méthode bloque le thread actuel et peut provoquer le blocage de l'application.Otherwise, the runtime throws concurrency::invalid_operation because this method blocks the current thread and can cause the app to become unresponsive. Toutefois, vous pouvez appeler la méthode concurrency::task::get pour recevoir le résultat de la tâche précédente dans une continuation basée sur des tâches.However, you can call the concurrency::task::get method to receive the result of the antecedent task in a task-based continuation.

Voir aussiSee also

Espace de noms d’accès concurrentielconcurrency Namespace