Task<TResult> Classe
Définition
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 qui peut retourner une valeur.
generic <typename TResult>
public ref class Task : System::Threading::Tasks::Task
public class Task<TResult> : System.Threading.Tasks.Task
type Task<'Result> = class
inherit Task
Public Class Task(Of TResult)
Inherits Task
Paramètres de type
- TResult
Type du résultat produit par ce Task<TResult>.
- Héritage
Remarques
La Task<TResult> classe représente une seule opération qui retourne une valeur et qui s’exécute généralement de manière asynchrone. Task<TResult> Les objets sont l’un des composants centraux du modèle asynchrone basé sur les tâches introduit pour la première fois dans .NET Framework 4. Étant donné que le travail effectué par un Task<TResult> objet s’exécute généralement de manière asynchrone sur un thread de pool de threads plutôt que de manière synchrone sur le thread d’application main, vous pouvez utiliser la Status propriété , ainsi que les IsCanceledpropriétés , IsCompletedet IsFaulted , pour déterminer l’état d’une tâche. Le plus souvent, une expression lambda est utilisée pour spécifier le travail que la tâche doit effectuer.
Task<TResult> les instances peuvent être créées de différentes façons. L’approche la plus courante, disponible à partir de .NET Framework 4.5, consiste à appeler la méthode statique Task.Run<TResult>(Func<TResult>) ou Task.Run<TResult>(Func<TResult>, CancellationToken) . Ces méthodes offrent un moyen simple de démarrer une tâche à l’aide de valeurs par défaut et sans acquérir de paramètres supplémentaires. L’exemple suivant utilise la Task.Run<TResult>(Func<TResult>) méthode pour démarrer 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.
Imports System.Threading.Tasks
Module Example
Public Sub Main()
Dim t As Task(Of Integer) = Task.Run(Function()
Dim max As Integer = 1000000
Dim ctr As Integer
For ctr = 0 to max
If ctr = max \ 2 And Date.Now.Hour <= 12 Then
ctr += 1
Exit For
End If
Next
Return ctr
End Function)
Console.WriteLine("Finished {0:N0} iterations.", t.Result)
End Sub
End Module
' The example displays the following output:
' Finished 1,000,001 loop iterations
Une alternative, et la méthode la plus courante pour démarrer une tâche dans .NET Framework 4, consiste à appeler la méthode statique TaskFactory.StartNew ou TaskFactory<TResult>.StartNew . La Task.Factory propriété renvoie un TaskFactory objet et la Task<TResult>.Factory propriété renvoie un TaskFactory<TResult> objet . Les surcharges de leur StartNew
méthode vous permettent de passer des arguments, de définir des options de création de tâches et de spécifier un planificateur de tâches. L’exemple suivant utilise la TaskFactory<TResult>.StartNew(Func<TResult>) méthode pour démarrer une tâche. Elle est fonctionnellement équivalente au code de 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
Imports System.Threading.Tasks
Module Example
Public Sub Main()
Dim t = Task(Of Integer).Factory.StartNew(Function()
Dim max As Integer = 1000000
Dim ctr As Integer
For ctr = 0 to max
If ctr = max \ 2 And Date.Now.Hour <= 12 Then
ctr += 1
Exit For
End If
Next
Return ctr
End Function)
Console.WriteLine("Finished {0:N0} iterations.", t.Result)
End Sub
End Module
' The example displays output like the following:
' Finished 1,000,001 iterations
Pour obtenir des exemples plus complets, consultez Programmation asynchrone basée sur les tâches.
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, les Task.Run méthodes et Task.Factory.StartNew
sont les mécanismes préférés pour créer et planifier des tâches de calcul, mais pour les scénarios où la création et la planification des tâches doivent être séparées, les constructeurs peuvent être utilisés, et la méthode de Start la tâche peut ensuite être utilisée pour planifier la tâche en vue de son exécution ultérieurement.
À compter des applications de bureau qui ciblent le .NET Framework 4.6, la culture du thread qui crée et appelle une tâche fait partie du contexte du thread. Autrement dit, quelle que soit la culture actuelle du thread sur lequel la tâche s’exécute, la culture actuelle de la tâche est la culture du thread appelant. Pour les applications qui ciblent des versions du .NET Framework antérieures à .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 les tâches » dans la CultureInfo rubrique. Notez que les applications du Windows Store suivent les 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, utilisez la Task classe . À compter de C# 7.0, pour une tâche plus légère qui est un type valeur plutôt qu’un type référence, utilisez la System.Threading.Tasks.ValueTask<TResult> structure .
Constructeurs
Task<TResult>(Func<Object,TResult>, Object) |
Initialise un nouveau Task<TResult> avec la fonction et l'état spécifiés. |
Task<TResult>(Func<Object,TResult>, Object, CancellationToken) |
Initialise une nouvelle Task<TResult> avec l'action, l'état et les options spécifiés. |
Task<TResult>(Func<Object,TResult>, Object, CancellationToken, TaskCreationOptions) |
Initialise une nouvelle Task<TResult> avec l'action, l'état et les options spécifiés. |
Task<TResult>(Func<Object,TResult>, Object, TaskCreationOptions) |
Initialise une nouvelle Task<TResult> avec l'action, l'état et les options spécifiés. |
Task<TResult>(Func<TResult>) |
Initialise une nouvelle Task<TResult> avec la fonction spécifiée. |
Task<TResult>(Func<TResult>, CancellationToken) |
Initialise une nouvelle Task<TResult> avec la fonction spécifiée. |
Task<TResult>(Func<TResult>, CancellationToken, TaskCreationOptions) |
Initialise une nouvelle Task<TResult> avec la fonction et les options de création spécifiées. |
Task<TResult>(Func<TResult>, TaskCreationOptions) |
Initialise une nouvelle Task<TResult> avec la fonction et les options de création spécifiées. |
Propriétés
AsyncState |
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) |
CreationOptions |
Obtient les TaskCreationOptions utilisées pour créer cette tâche. (Hérité de Task) |
Exception |
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 |
Factory |
Obtient une méthode de fabrique pour créer et configurer des Task<TResult> instances. |
Id |
Obtient un ID pour cette instance de Task. (Hérité de Task) |
IsCanceled |
Indique si cette instance de Task s'est exécutée avec succès suite à une annulation. (Hérité de Task) |
IsCompleted |
Obtient une valeur indiquant si la tâche est terminée. (Hérité de Task) |
IsCompletedSuccessfully |
Obtient une valeur indiquant si la tâche s’est exécutée jusqu’à son achèvement. (Hérité de Task) |
IsFaulted |
Indique si la Task s'est terminée suite à une exception non gérée. (Hérité de Task) |
Result |
Obtient la valeur de résultat de cette Task<TResult>. |
Status |
Obtient le TaskStatus de cette tâche. (Hérité de Task) |
Méthodes
ConfigureAwait(Boolean) |
Configure un élément awaiter utilisé pour attendre cette Task<TResult>. |
ConfigureAwait(Boolean) |
Configure un élément awaiter utilisé pour attendre cette Task. (Hérité de Task) |
ConfigureAwait(ConfigureAwaitOptions) |
Configure un élément awaiter utilisé pour attendre cette Task. |
ConfigureAwait(ConfigureAwaitOptions) |
Configure un élément awaiter utilisé pour attendre cette Task. (Hérité de Task) |
ContinueWith(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) |
ContinueWith(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) |
ContinueWith(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) |
ContinueWith(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) |
ContinueWith(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) |
ContinueWith(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 s’exécute. |
ContinueWith(Action<Task<TResult>,Object>, Object, CancellationToken) |
Crée une continuation qui s'exécute quand la Task<TResult> cible se termine. |
ContinueWith(Action<Task<TResult>,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler) |
Crée une continuation qui s'exécute quand la Task<TResult> cible se termine. |
ContinueWith(Action<Task<TResult>,Object>, Object, TaskContinuationOptions) |
Crée une continuation qui s'exécute quand la Task<TResult> cible se termine. |
ContinueWith(Action<Task<TResult>,Object>, Object, TaskScheduler) |
Crée une continuation qui s'exécute quand la Task<TResult> cible se termine. |
ContinueWith(Action<Task<TResult>>) |
Crée une continuation qui s’exécute de façon asynchrone quand la tâche cible se termine. |
ContinueWith(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. |
ContinueWith(Action<Task<TResult>>, CancellationToken, TaskContinuationOptions, TaskScheduler) |
Crée une continuation qui s'exécute en fonction de la condition spécifiée dans |
ContinueWith(Action<Task<TResult>>, TaskContinuationOptions) |
Crée une continuation qui s'exécute en fonction de la condition spécifiée dans |
ContinueWith(Action<Task<TResult>>, TaskScheduler) |
Crée une continuation qui s'exécute de façon asynchrone quand la Task<TResult> cible se termine. |
ContinueWith(Action<Task>) |
Crée une continuation qui s'exécute de façon asynchrone quand la Task cible se termine. (Hérité de Task) |
ContinueWith(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) |
ContinueWith(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) |
ContinueWith(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) |
ContinueWith(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) |
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object) |
Crée une continuation qui s'exécute quand la Task<TResult> cible se termine. |
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, CancellationToken) |
Crée une continuation qui s'exécute quand la Task<TResult> cible se termine. |
ContinueWith<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. |
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, TaskContinuationOptions) |
Crée une continuation qui s'exécute quand la Task<TResult> cible se termine. |
ContinueWith<TNewResult>(Func<Task<TResult>,Object,TNewResult>, Object, TaskScheduler) |
Crée une continuation qui s'exécute quand la Task<TResult> cible se termine. |
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>) |
Crée une continuation qui s'exécute de façon asynchrone quand la Task<TResult> cible se termine. |
ContinueWith<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. |
ContinueWith<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 |
ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>, TaskContinuationOptions) |
Crée une continuation qui s'exécute en fonction de la condition spécifiée dans |
ContinueWith<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. |
ContinueWith<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) |
ContinueWith<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) |
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 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) |
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 quand le Task cible se termine. La continuation reçoit des informations d'état fournies par l'appelant. (Hérité de Task) |
ContinueWith<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) |
ContinueWith<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) |
ContinueWith<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) |
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 reçoit un jeton d'annulation et utilise un planificateur spécifié. (Hérité de Task) |
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. (Hérité de Task) |
ContinueWith<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) |
Dispose() |
Libère toutes les ressources utilisées par l'instance actuelle de la classe Task. (Hérité de Task) |
Dispose(Boolean) |
Supprime la Task, en libérant toutes ses ressources non managées. (Hérité de Task) |
Equals(Object) |
Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object) |
GetAwaiter() |
Obtient un élément awaiter utilisé pour attendre cette Task<TResult>. |
GetAwaiter() |
Obtient un élément awaiter utilisé pour attendre cette Task. (Hérité de Task) |
GetHashCode() |
Fait office de fonction de hachage par défaut. (Hérité de Object) |
GetType() |
Obtient le Type de l'instance actuelle. (Hérité de Object) |
MemberwiseClone() |
Crée une copie superficielle du Object actuel. (Hérité de Object) |
RunSynchronously() |
Exécute de façon synchrone la Task sur le TaskScheduler actuel. (Hérité de Task) |
RunSynchronously(TaskScheduler) |
Exécute de façon synchrone le Task sur le TaskScheduler fourni. (Hérité de Task) |
Start() |
Démarre la Task, en planifiant son exécution sur le TaskScheduler actuel. (Hérité de Task) |
Start(TaskScheduler) |
Démarre la Task, en planifiant son exécution sur le TaskScheduler spécifié. (Hérité de Task) |
ToString() |
Retourne une chaîne qui représente l'objet actuel. (Hérité de Object) |
Wait() |
Attend la fin de l'exécution de Task. (Hérité de Task) |
Wait(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) |
Wait(Int32) |
Attend la fin de l'exécution de la Task en un nombre de millisecondes spécifié. (Hérité de Task) |
Wait(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) |
Wait(TimeSpan) |
Attend la fin de l'exécution de la Task dans un intervalle de temps spécifié. (Hérité de Task) |
Wait(TimeSpan, CancellationToken) |
Attend la fin de l'exécution de Task. (Hérité de Task) |
WaitAsync(CancellationToken) |
Obtient un Task<TResult> qui se termine à la fin de l’opération Task<TResult> ou lorsque l’annulation demandée est demandée par le spécifié CancellationToken . |
WaitAsync(CancellationToken) |
Obtient un Task qui se termine à la fin de l’opération Task ou lorsque l’annulation demandée est demandée par le spécifié CancellationToken . (Hérité de Task) |
WaitAsync(TimeSpan) |
Obtient un Task<TResult> qui se termine à la fin de l’opération Task<TResult> ou à l’expiration du délai d’expiration spécifié. |
WaitAsync(TimeSpan) |
Obtient un Task qui se termine à la fin de l’opération Task ou à l’expiration du délai d’expiration spécifié. (Hérité de Task) |
WaitAsync(TimeSpan, CancellationToken) |
Obtient un Task<TResult> qui se termine à la fin de cette Task<TResult> opération, lorsque le délai d’expiration spécifié expire ou lorsque l’annulation spécifiée CancellationToken est demandée. |
WaitAsync(TimeSpan, CancellationToken) |
Obtient un Task qui se termine à la fin de cette Task opération, lorsque le délai d’expiration spécifié expire ou lorsque l’annulation spécifiée CancellationToken est demandée. (Hérité de Task) |
WaitAsync(TimeSpan, TimeProvider) |
Obtient un Task<TResult> qui se termine à la fin de l’opération Task<TResult> ou à l’expiration du délai d’expiration spécifié. |
WaitAsync(TimeSpan, TimeProvider) |
Obtient un Task qui se termine à la fin de l’opération Task ou à l’expiration du délai d’expiration spécifié. (Hérité de Task) |
WaitAsync(TimeSpan, TimeProvider, CancellationToken) |
Obtient un Task<TResult> qui se termine à la fin de cette Task<TResult> opération, lorsque le délai d’expiration spécifié expire ou lorsque l’annulation spécifiée CancellationToken est demandée. |
WaitAsync(TimeSpan, TimeProvider, CancellationToken) |
Obtient un Task qui se termine à la fin de cette Task opération, lorsque le délai d’expiration spécifié expire ou lorsque l’annulation spécifiée CancellationToken est demandée. (Hérité de Task) |
Implémentations d’interfaces explicites
IAsyncResult.AsyncWaitHandle |
Obtient un WaitHandle qui peut être utilisé en attendant la fin de la tâche. (Hérité de Task) |
IAsyncResult.CompletedSynchronously |
Obtient une indication précisant si l’opération s’est terminée de manière synchrone. (Hérité de Task) |
Méthodes d’extension
AsyncWait<TException>(Task) |
Représente une opération asynchrone qui peut retourner une valeur. |
AwaitWithTimeout(Task, TimeSpan) |
Représente une opération asynchrone qui peut retourner une valeur. |
ToApm(Task, AsyncCallback, Object) |
Représente une opération asynchrone qui peut retourner une valeur. |
ToApm<TResult>(Task<TResult>, AsyncCallback, Object) |
Représente une opération asynchrone qui peut retourner une valeur. |
ToApmEnd(IAsyncResult) |
Représente une opération asynchrone qui peut retourner une valeur. |
ToApmEnd<TResult>(IAsyncResult) |
Représente une opération asynchrone qui peut retourner une valeur. |
Wait(Task, TimeSpan, Action<Exception,TimeSpan,String>, String) |
Représente une opération asynchrone qui peut retourner une valeur. |
WaitForCompletion(Task) |
Représente une opération asynchrone qui peut retourner une valeur. |
WaitForCompletion<TResult>(Task<TResult>) |
Représente une opération asynchrone qui peut retourner une valeur. |
WaitForCompletionNoSpin(Task) |
Représente une opération asynchrone qui peut retourner une valeur. |
WaitForCompletionNoSpin(Task, TimeSpan) |
Représente une opération asynchrone qui peut retourner une valeur. |
WaitForCompletionNoSpin<TResult>(Task<TResult>) |
Représente une opération asynchrone qui peut retourner une valeur. |
WaitAsync(Task, TimeSpan, TimeProvider, CancellationToken) |
Représente une opération asynchrone qui peut retourner une valeur. |
WaitAsync<TResult>(Task<TResult>, TimeSpan, TimeProvider, CancellationToken) |
Représente une opération asynchrone qui peut retourner une valeur. |
DispatcherOperationWait(Task) |
Attend indéfiniment que l'opération DispatcherOperation sous-jacente se termine. |
DispatcherOperationWait(Task, TimeSpan) |
Attend pendant le délai spécifié que le DispatcherOperation sous-jacente se termine. |
IsDispatcherOperationTask(Task) |
Retourne une valeur qui indique si cette Task est associée à une DispatcherOperation. |
AsAsyncAction(Task) |
Retourne une action asynchrone Windows Runtime qui représente une tâche initiée. |
AsAsyncOperation<TResult>(Task<TResult>) |
Retourne une opération asynchrone Windows Runtime qui représente une tâche démarrée qui retourne un résultat. |
S’applique à
Cohérence de thread
Tous les membres de , à l’exception de Task<TResult>Dispose(), sont thread-safe et peuvent être utilisés simultanément à partir de plusieurs threads.
Voir aussi
Commentaires
https://aka.ms/ContentUserFeedback.
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultezEnvoyer et afficher des commentaires pour