Task Classe

Référence

Définition

Espace de noms:: System.Threading.Tasks

Assembly:: System.Threading.Tasks.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Source:: Task.cs

Source:: Task.cs

Source:: Task.cs

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Représente une opération asynchrone.

public ref class Task : IAsyncResult

public ref class Task : IAsyncResult, IDisposable

public class Task : IAsyncResult

public class Task : IAsyncResult, IDisposable

type Task = class
    interface IAsyncResult

type Task = class
    interface IAsyncResult
    interface IDisposable

Public Class Task
Implements IAsyncResult

Public Class Task
Implements IAsyncResult, IDisposable

Héritage: Object
Task

Dérivé: System.Threading.Tasks.Task<TResult>

Implémente: IAsyncResult IDisposable

Remarques

Pour plus d’informations sur cette API, consultez remarques sur l’API supplémentaire pour la tâche.

Constructeurs

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

Propriétés

AsyncState	Obtient l’objet d’état fourni lorsque l'Task a été créé ou null si aucun n’a été fourni.
CompletedTask	Obtient une tâche qui s’est déjà terminée avec succès.
CreationOptions	Obtient la TaskCreationOptions utilisée pour créer cette tâche.
CurrentId	Retourne l’ID de l'Tasken cours d’exécution.
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`.
Factory	Fournit l’accès aux méthodes de fabrique pour créer et configurer des instances de Task et de Task<TResult>.
Id	Obtient un ID pour cette instance Task.
IsCanceled	Obtient si cette instance Task a terminé l’exécution en raison d’une annulation.
IsCompleted	Obtient une valeur qui indique si la tâche est terminée.
IsCompletedSuccessfully	Obtient si la tâche s’est exécutée à la fin.
IsFaulted	Obtient si le Task terminé en raison d’une exception non gérée.
Status	Obtient la TaskStatus de cette tâche.

Méthodes

ConfigureAwait(Boolean)	Configure un awaiter utilisé pour attendre ce Task.
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é.
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.
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é.
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.
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é.
ContinueWith(Action<Task>)	Crée une continuation qui s’exécute de manière asynchrone lorsque le Task cible est terminé.
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.
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é.
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.
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é.
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.
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.
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é.
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.
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é.
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.
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.
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é.
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.
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é.
Delay(Int32)	Crée une tâche qui se termine après un nombre spécifié de millisecondes.
Delay(Int32, CancellationToken)	Crée une tâche annulable qui se termine après un nombre spécifié de millisecondes.
Delay(TimeSpan)	Crée une tâche qui se termine après un intervalle de temps spécifié.
Delay(TimeSpan, CancellationToken)	Crée une tâche annulable qui se termine après un intervalle de temps spécifié.
Delay(TimeSpan, TimeProvider)	Crée une tâche qui se termine après un intervalle de temps spécifié.
Delay(TimeSpan, TimeProvider, CancellationToken)	Crée une tâche annulable qui se termine après un intervalle de temps spécifié.
Dispose()	Libère toutes les ressources utilisées par l’instance actuelle de la classe Task.
Dispose(Boolean)	Supprime le Task, en libérant toutes ses ressources non managées.
Equals(Object)	Détermine si l’objet spécifié est égal à l’objet actuel. (Hérité de Object)
FromCanceled(CancellationToken)	Crée une Task terminée en raison de l’annulation avec un jeton d’annulation spécifié.
FromCanceled<TResult>(CancellationToken)	Crée une Task<TResult> terminée en raison de l’annulation avec un jeton d’annulation spécifié.
FromException(Exception)	Crée un Task qui s’est terminé avec une exception spécifiée.
FromException<TResult>(Exception)	Crée une Task<TResult> terminée avec une exception spécifiée.
FromResult<TResult>(TResult)	Crée une Task<TResult> terminée avec le résultat spécifié.
GetAwaiter()	Obtient un awaiter utilisé pour attendre ce Task.
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)
Run(Action)	Met en file d’attente le travail spécifié à exécuter sur le pool de threads et retourne un objet Task qui représente ce travail.
Run(Action, CancellationToken)	Met en file d’attente le travail spécifié à exécuter sur le pool de threads et retourne un objet Task qui représente ce travail. Un jeton d’annulation permet d’annuler le travail s’il n’a pas encore démarré.
Run(Func<Task>)	Met en file d’attente le travail spécifié à exécuter sur le pool de threads et retourne un proxy pour la tâche retournée par `function`.
Run(Func<Task>, CancellationToken)	Met en file d’attente le travail spécifié à exécuter sur le pool de threads et retourne un proxy pour la tâche retournée par `function`. Un jeton d’annulation permet d’annuler le travail s’il n’a pas encore démarré.
Run<TResult>(Func<Task<TResult>>)	Met en file d’attente le travail spécifié à exécuter sur le pool de threads et retourne un proxy pour le `Task(TResult)` retourné par `function`. Un jeton d’annulation permet d’annuler le travail s’il n’a pas encore démarré.
Run<TResult>(Func<Task<TResult>>, CancellationToken)	Met en file d’attente le travail spécifié à exécuter sur le pool de threads et retourne un proxy pour le `Task(TResult)` retourné par `function`.
Run<TResult>(Func<TResult>)	Met en file d’attente le travail spécifié à exécuter sur le pool de threads et retourne un objet Task<TResult> qui représente ce travail. Un jeton d’annulation permet d’annuler le travail s’il n’a pas encore démarré.
Run<TResult>(Func<TResult>, CancellationToken)	Met en file d’attente le travail spécifié à exécuter sur le pool de threads et retourne un objet `Task(TResult)` qui représente ce travail.
RunSynchronously()	Exécute la Task de manière synchrone sur le TaskScheduleractuel.
RunSynchronously(TaskScheduler)	Exécute la Task de manière synchrone sur le TaskScheduler fourni.
Start()	Démarre l'Task, en le planifiant pour l’exécution sur le TaskScheduleractuel.
Start(TaskScheduler)	Démarre la Task, en la planifiant pour l’exécution sur la TaskSchedulerspécifiée.
ToString()	Retourne une chaîne qui représente l’objet actuel. (Hérité de Object)
Wait()	Attend que le Task termine l’exécution.
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.
Wait(Int32)	Attend que le Task termine l’exécution dans un nombre spécifié de millisecondes.
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.
Wait(TimeSpan)	Attend que le Task termine l’exécution dans un intervalle de temps spécifié.
Wait(TimeSpan, CancellationToken)	Attend que le Task termine l’exécution.
WaitAll(IEnumerable<Task>, CancellationToken)	Attend que tous les objets Task fournis terminent l’exécution, sauf si l’attente est annulée.
WaitAll(ReadOnlySpan<Task>)	Attend que tous les objets Task fournis terminent l’exécution.
WaitAll(Task[])	Attend que tous les objets Task fournis terminent l’exécution.
WaitAll(Task[], CancellationToken)	Attend que tous les objets Task fournis terminent l’exécution, sauf si l’attente est annulée.
WaitAll(Task[], Int32)	Attend que tous les objets Task fournis terminent l’exécution dans un nombre spécifié de millisecondes.
WaitAll(Task[], Int32, CancellationToken)	Attend que tous les objets Task fournis terminent l’exécution dans un nombre spécifié de millisecondes ou jusqu’à ce que l’attente soit annulée.
WaitAll(Task[], TimeSpan)	Attend que tous les objets Task annulés fournis terminent l’exécution dans un intervalle de temps spécifié.
WaitAny(Task[])	Attend que l’un des objets Task fournis termine l’exécution.
WaitAny(Task[], CancellationToken)	Attend que l’un des objets Task fournis termine l’exécution, sauf si l’attente est annulée.
WaitAny(Task[], Int32)	Attend que l’un des objets Task fournis termine l’exécution dans un nombre spécifié de millisecondes.
WaitAny(Task[], Int32, CancellationToken)	Attend que l’un des objets Task fournis termine l’exécution dans un nombre spécifié de millisecondes ou jusqu’à ce qu’un jeton d’annulation soit annulé.
WaitAny(Task[], TimeSpan)	Attend que l’un des objets Task fournis termine l’exécution dans un intervalle de temps spécifié.
WaitAsync(CancellationToken)	Obtient un Task qui se termine lorsque cette Task se termine ou lorsque le CancellationToken spécifié a demandé l’annulation.
WaitAsync(TimeSpan)	Obtient une Task qui se termine lorsque cette Task se termine ou lorsque le délai d’expiration spécifié expire.
WaitAsync(TimeSpan, 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(TimeSpan, TimeProvider)	Obtient une Task qui se termine lorsque cette Task se termine ou lorsque le délai d’expiration spécifié expire.
WaitAsync(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.
WhenAll(IEnumerable<Task>)	Crée une tâche qui se termine lorsque tous les objets Task d’une collection énumérable sont terminés.
WhenAll(ReadOnlySpan<Task>)	Crée une tâche qui se termine lorsque toutes les tâches fournies sont terminées.
WhenAll(Task[])	Crée une tâche qui se termine lorsque tous les objets Task d’un tableau sont terminés.
WhenAll<TResult>(IEnumerable<Task<TResult>>)	Crée une tâche qui se termine lorsque tous les objets Task<TResult> d’une collection énumérable sont terminés.
WhenAll<TResult>(ReadOnlySpan<Task<TResult>>)	Crée une tâche qui se termine lorsque toutes les tâches fournies sont terminées.
WhenAll<TResult>(Task<TResult>[])	Crée une tâche qui se termine lorsque tous les objets Task<TResult> d’un tableau sont terminés.
WhenAny(IEnumerable<Task>)	Crée une tâche qui se termine lorsque l’une des tâches fournies est terminée.
WhenAny(ReadOnlySpan<Task>)	Crée une tâche qui se termine lorsque l’une des tâches fournies est terminée.
WhenAny(Task, Task)	Crée une tâche qui se termine lorsque l’une des tâches fournies est terminée.
WhenAny(Task[])	Crée une tâche qui se termine lorsque l’une des tâches fournies est terminée.
WhenAny<TResult>(IEnumerable<Task<TResult>>)	Crée une tâche qui se termine lorsque l’une des tâches fournies est terminée.
WhenAny<TResult>(ReadOnlySpan<Task<TResult>>)	Crée une tâche qui se termine lorsque l’une des tâches fournies est terminée.
WhenAny<TResult>(Task<TResult>, Task<TResult>)	Crée une tâche qui se termine lorsque l’une des tâches fournies est terminée.
WhenAny<TResult>(Task<TResult>[])	Crée une tâche qui se termine lorsque l’une des tâches fournies est terminée.
WhenEach(IEnumerable<Task>)	Crée un IAsyncEnumerable<T> qui génère les tâches fournies à mesure que ces tâches se terminent.
WhenEach(ReadOnlySpan<Task>)	Crée un IAsyncEnumerable<T> qui génère les tâches fournies à mesure que ces tâches se terminent.
WhenEach(Task[])	Crée un IAsyncEnumerable<T> qui génère les tâches fournies à mesure que ces tâches se terminent.
WhenEach<TResult>(IEnumerable<Task<TResult>>)	Crée un IAsyncEnumerable<T> qui génère les tâches fournies à mesure que ces tâches se terminent.
WhenEach<TResult>(ReadOnlySpan<Task<TResult>>)	Crée un IAsyncEnumerable<T> qui génère les tâches fournies à mesure que ces tâches se terminent.
WhenEach<TResult>(Task<TResult>[])	Crée un IAsyncEnumerable<T> qui génère les tâches fournies à mesure que ces tâches se terminent.
Yield()	Crée une tâche awaitable qui retourne de façon asynchrone le contexte actuel lorsque vous l’attendez.

Implémentations d’interfaces explicites

IAsyncResult.AsyncWaitHandle	Obtient une WaitHandle qui peut être utilisée pour attendre la fin de la tâche.
IAsyncResult.CompletedSynchronously	Obtient une indication indiquant si l’opération s’est terminée de façon synchrone.

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.
DispatcherOperationWait(Task)	Attend indéfiniment que le DispatcherOperation sous-jacent se termine.
DispatcherOperationWait(Task, TimeSpan)	Attend la fin de la DispatcherOperation sous-jacente pendant la durée spécifiée.
IsDispatcherOperationTask(Task)	Retourne une valeur qui indique si cette Task est associée à un DispatcherOperation.
AsAsyncAction(Task)	Retourne une action asynchrone Windows Runtime qui représente une tâche démarrée.

S’applique à

Cohérence de thread

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

Partage via