Task Classe

Définition

Espace de noms:
System.Threading.Tasks
Assemblys:
mscorlib.dll, System.Threading.Tasks.dll
Assembly:
mscorlib.dll
Assembly:
System.Threading.Tasks.dll
Assembly:
netstandard.dll

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é
Implémente
IAsyncResult IDisposable

Remarques

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

Constructeurs

Nom Description
Task(Action, CancellationToken, TaskCreationOptions)

Initialise une nouvelle Task avec les options d’action et de création spécifiées.
Task(Action, CancellationToken)

Initialise un nouveau Task avec l’action spécifiée et CancellationToken.
Task(Action, TaskCreationOptions)

Initialise une nouvelle Task avec les options d’action et de création spécifiées.
Task(Action)

Initialise un nouveau Task avec l’action spécifiée.
Task(Action<Object>, Object, CancellationToken, TaskCreationOptions)

Initialise un nouveau Task avec l’action, l’état et les options spécifiés.
Task(Action<Object>, Object, CancellationToken)

Initialise une nouvelle Task avec l’action, l’état et CancellationToken.
Task(Action<Object>, Object, TaskCreationOptions)

Initialise un nouveau Task avec l’action, l’état et les options spécifiés.
Task(Action<Object>, Object)

Initialise un nouveau Task avec l’action et l’état spécifiés.

Propriétés

Nom Description
AsyncState

Obtient l’objet d’état fourni lors de la création ou de la Task valeur Null si aucun n’a été fourni.
CompletedTask

Obtient une tâche qui s’est déjà terminée avec succès.
CreationOptions

Obtient l’élément TaskCreationOptions utilisé pour créer cette tâche.
CurrentId

Retourne l’ID de l’exécution Taskactuelle .
Exception

Obtient l’élément AggregateException qui a provoqué la Task fin prématurément. Si l’opération 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 la création et la configuration Task et Task<TResult> les instances.
Id

Obtient un ID pour cette Task instance.
IsCanceled

Obtient si cette Task instance 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 l’opération Task terminée en raison d’une exception non gérée.
Status

Obtient la TaskStatus tâche.

Méthodes

Nom Description
ConfigureAwait(Boolean)

Configure un awaiter utilisé pour l’attendre Task.
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 une fois la cible Task terminée. 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, 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 la cible Task se termine.
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 une fois la cible Task terminée. 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 la cible Task se termine. La continuation utilise un planificateur spécifié.
ContinueWith(Action<Task,Object>, Object)

Crée une continuation qui reçoit les informations d’état fournies par l’appelant et s’exécute une fois la cible Task terminée.
ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Crée une continuation qui s’exécute lorsque la tâche cible est en concurrence en fonction de la valeur spécifiée TaskContinuationOptions. La continuation reçoit un jeton d’annulation et utilise un planificateur spécifié.
ContinueWith(Action<Task>, CancellationToken)

Crée une continuation qui reçoit un jeton d’annulation et s’exécute de façon asynchrone une fois la cible Task terminée.
ContinueWith(Action<Task>, TaskContinuationOptions)

Crée une continuation qui s’exécute lorsque la tâche cible se termine en fonction de la valeur spécifiée TaskContinuationOptions.
ContinueWith(Action<Task>, TaskScheduler)

Crée une continuation qui s’exécute de manière asynchrone une fois la cible Task terminée. La continuation utilise un planificateur spécifié.
ContinueWith(Action<Task>)

Crée une continuation qui s’exécute de manière asynchrone une fois la cible Task terminée.
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 la cible Task 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, CancellationToken)

Crée une continuation qui s’exécute de façon asynchrone lorsque la cible Task 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, TaskContinuationOptions)

Crée une continuation qui s’exécute en fonction des options de continuation de tâche spécifiées une fois la cible Task terminée. 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 une fois la cible Task terminée. La continuation reçoit les informations d’état fournies par l’appelant et 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 la cible Task se termine et retourne une valeur.
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>, CancellationToken)

Crée une continuation qui s’exécute de façon asynchrone lorsque la cible Task se termine et retourne une valeur. La continuation reçoit un jeton d’annulation.
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 la cible Task se termine et retourne une valeur. La continuation utilise un planificateur spécifié.
ContinueWith<TResult>(Func<Task,TResult>)

Crée une continuation qui s’exécute de façon asynchrone lorsque la cible Task<TResult> se termine et retourne une valeur.
Delay(Int32, CancellationToken)

Crée une tâche annulable qui se termine après un nombre spécifié de millisecondes.
Delay(Int32)

Crée une tâche qui se termine après un nombre spécifié de millisecondes.
Delay(TimeSpan, CancellationToken)

Crée une tâche annulable qui se termine après un intervalle de temps spécifié.
Delay(TimeSpan)

Crée une tâche 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 Task classe.
Dispose(Boolean)

Supprime , Tasklibère 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 un Task élément terminé en raison de l’annulation avec un jeton d’annulation spécifié.
FromCanceled<TResult>(CancellationToken)

Crée un Task<TResult> élément terminé 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 un Task<TResult> élément terminé avec une exception spécifiée.
FromResult<TResult>(TResult)

Crée un résultat Task<TResult> terminé 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, CancellationToken)

Met en file d’attente le travail spécifié à exécuter sur le pool de threads et retourne un Task objet qui représente ce travail. Un jeton d’annulation permet d’annuler le travail s’il n’a pas encore démarré.
Run(Action)

Met en file d’attente le travail spécifié à exécuter sur le pool de threads et retourne un Task objet qui représente ce travail.
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(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<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) retour par function.
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) retour par function. 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 Task(TResult) objet qui représente ce travail.
Run<TResult>(Func<TResult>)

Met en file d’attente le travail spécifié à exécuter sur le pool de threads et retourne un Task<TResult> objet qui représente ce travail. Un jeton d’annulation permet d’annuler le travail s’il n’a pas encore démarré.
RunSynchronously()

S’exécute Task de manière synchrone sur le fichier actif TaskScheduler.
RunSynchronously(TaskScheduler)

Exécute la Task synchronisation sur l’élément TaskScheduler fourni.
Start()

Démarre le Task, en le planifiant pour l’exécution vers l’actif TaskScheduler.
Start(TaskScheduler)

Démarre le Task, en le planifiant pour l’exécution sur le fichier spécifié TaskScheduler.
ToString()

Retourne une chaîne qui représente l’objet actuel.

(Hérité de Object)
Wait()

Attend la fin de l’exécution Task .
Wait(CancellationToken)

Attend la fin de l’exécution Task . L’attente se termine si un jeton d’annulation est annulé avant la fin de la tâche.
Wait(Int32, CancellationToken)

Attend la fin de l’exécution Task . 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(Int32)

Attend la fin de l’exécution Task dans un nombre spécifié de millisecondes.
Wait(TimeSpan)

Attend la fin de l’exécution Task dans un intervalle de temps spécifié.
WaitAll(Task[], CancellationToken)

Attend que tous les objets fournis Task terminent l’exécution, sauf si l’attente est annulée.
WaitAll(Task[], Int32, CancellationToken)

Attend que tous les objets fournis Task terminent l’exécution dans un nombre spécifié de millisecondes ou jusqu’à ce que l’attente soit annulée.
WaitAll(Task[], Int32)

Attend que tous les objets fournis Task terminent l’exécution dans un nombre spécifié de millisecondes.
WaitAll(Task[], TimeSpan)

Attend que tous les objets annulables Task fournis terminent l’exécution dans un intervalle de temps spécifié.
WaitAll(Task[])

Attend que tous les objets fournis Task terminent l’exécution.
WaitAny(Task[], CancellationToken)

Attend que l’un des objets fournis Task termine l’exécution, sauf si l’attente est annulée.
WaitAny(Task[], Int32, CancellationToken)

Attend que l’un des objets fournis Task termine l’exécution dans un nombre spécifié de millisecondes ou jusqu’à ce qu’un jeton d’annulation soit annulé.
WaitAny(Task[], Int32)

Attend que l’un des objets fournis Task termine l’exécution dans un nombre spécifié de millisecondes.
WaitAny(Task[], TimeSpan)

Attend que l’un des objets fournis Task termine l’exécution dans un intervalle de temps spécifié.
WaitAny(Task[])

Attend que l’un des objets fournis Task termine l’exécution.
WhenAll(IEnumerable<Task>)

Crée une tâche qui se termine lorsque tous les Task objets d’une collection énumérable sont terminés.
WhenAll(Task[])

Crée une tâche qui se termine lorsque tous les Task objets d’un tableau sont terminés.
WhenAll<TResult>(IEnumerable<Task<TResult>>)

Crée une tâche qui se termine lorsque tous les Task<TResult> objets d’une collection énumérable sont terminés.
WhenAll<TResult>(Task<TResult>[])

Crée une tâche qui se termine lorsque tous les Task<TResult> objets 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(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>(Task<TResult>[])

Crée une tâche qui se termine lorsque l’une des tâches fournies est terminée.
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

Nom Description
IAsyncResult.AsyncWaitHandle

Obtient un WaitHandle élément qui peut être utilisé 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

Nom Description
AsAsyncAction(Task)

Retourne une action asynchrone Windows Runtime qui représente une tâche démarrée.
DispatcherOperationWait(Task, TimeSpan)

Attend la fin du délai spécifié pour que le sous-jacent DispatcherOperation se termine.
DispatcherOperationWait(Task)

Attend indéfiniment que le sous-jacent DispatcherOperation se termine.
IsDispatcherOperationTask(Task)

Retourne une valeur qui indique si elle Task est associée à un DispatcherOperation.

S’applique à

Cohérence de thread

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

Voir aussi