Task Classe
Cet article a fait l'objet d'une traduction automatique. Déplacez votre pointeur sur les phrases de l'article pour voir la version originale de ce texte. Informations supplémentaires.
Traduction
Source

Task, classe

.NET Framework (current version)
 

Représente une opération asynchrone.

Pour parcourir le code source de .NET Framework pour ce type, consultez la Reference Source.

Espace de noms:   System.Threading.Tasks
Assembly:  mscorlib (dans mscorlib.dll)


[HostProtectionAttribute(SecurityAction.LinkDemand, Synchronization = true, 
	ExternalThreading = true)]
public class Task : IAsyncResult, IDisposable

NomDescription
System_CAPS_pubmethodTask(Action)

Initialise un nouveau Task avec l'action spécifiée.

System_CAPS_pubmethodTask(Action, CancellationToken)

Initialise un nouveau Task avec l'action spécifiée et CancellationToken.

System_CAPS_pubmethodTask(Action, CancellationToken, TaskCreationOptions)

Initialise une nouvelle Task avec l'action et les options de création spécifiées.

System_CAPS_pubmethodTask(Action, TaskCreationOptions)

Initialise une nouvelle Task avec l'action et les options de création spécifiées.

System_CAPS_pubmethodTask(Action<Object>, Object)

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

System_CAPS_pubmethodTask(Action<Object>, Object, CancellationToken)

Initialise une nouvelle Task avec l'action, l'état et les options spécifiés.

System_CAPS_pubmethodTask(Action<Object>, Object, CancellationToken, TaskCreationOptions)

Initialise une nouvelle Task avec l'action, l'état et les options spécifiés.

System_CAPS_pubmethodTask(Action<Object>, Object, TaskCreationOptions)

Initialise une nouvelle Task avec l'action, l'état et les options spécifiés.

NomDescription
System_CAPS_pubpropertyAsyncState

Obtient l'objet d'état fourni quand la Task a été créée, ou null si aucune n'a été fournie.

System_CAPS_pubpropertySystem_CAPS_staticCompletedTask

Obtient une tâche qui s'est déjà terminée correctement.

System_CAPS_pubpropertyCreationOptions

Obtient les TaskCreationOptions utilisées pour créer cette tâche.

System_CAPS_pubpropertySystem_CAPS_staticCurrentId

Retourne l'ID de la Task en cours d'exécution.

System_CAPS_pubpropertyException

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 null est retournée.

System_CAPS_pubpropertySystem_CAPS_staticFactory

Fournit l'accès aux méthodes de fabrique pour la création d'instances de Task et de Task<TResult>.

System_CAPS_pubpropertyId

Obtient un ID pour cette instance de Task.

System_CAPS_pubpropertyIsCanceled

Indique si cette instance de Task s'est exécutée avec succès suite à une annulation.

System_CAPS_pubpropertyIsCompleted

Indique si cette Task s'est terminée.

System_CAPS_pubpropertyIsFaulted

Indique si la Task s'est terminée suite à une exception non gérée.

System_CAPS_pubpropertyStatus

Obtient le TaskStatus de cette tâche.

NomDescription
System_CAPS_pubmethodConfigureAwait(Boolean)

Configure un élément awaiter utilisé pour attendre cette Task.

System_CAPS_pubmethodContinueWith(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.

System_CAPS_pubmethodContinueWith(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.

System_CAPS_pubmethodContinueWith(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é.

System_CAPS_pubmethodContinueWith(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.

System_CAPS_pubmethodContinueWith(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é.

System_CAPS_pubmethodContinueWith(Action<Task>)

Crée une continuation qui s'exécute de façon asynchrone quand la Task cible se termine.

System_CAPS_pubmethodContinueWith(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.

System_CAPS_pubmethodContinueWith(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é.

System_CAPS_pubmethodContinueWith(Action<Task>, TaskContinuationOptions)

Crée une continuation qui s'exécute quand la tâche cible se termine conformément au TaskContinuationOptions spécifié.

System_CAPS_pubmethodContinueWith(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é.

System_CAPS_pubmethodContinueWith<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.

System_CAPS_pubmethodContinueWith<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.

System_CAPS_pubmethodContinueWith<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é.

System_CAPS_pubmethodContinueWith<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.

System_CAPS_pubmethodContinueWith<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é.

System_CAPS_pubmethodContinueWith<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.

System_CAPS_pubmethodContinueWith<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.

System_CAPS_pubmethodContinueWith<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é.

System_CAPS_pubmethodContinueWith<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 et retourne une valeur.La continuation reçoit des informations d'état fournies par l'appelant.

System_CAPS_pubmethodContinueWith<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é.

System_CAPS_pubmethodSystem_CAPS_staticDelay(Int32)

Crée une tâche qui se termine après un certain délai.

System_CAPS_pubmethodSystem_CAPS_staticDelay(Int32, CancellationToken)

Crée une tâche pouvant être annulée qui se termine après un certain délai.

System_CAPS_pubmethodSystem_CAPS_staticDelay(TimeSpan)

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

System_CAPS_pubmethodSystem_CAPS_staticDelay(TimeSpan, CancellationToken)

Crée une tâche pouvant être annulée qui se termine après un intervalle de temps spécifié.

System_CAPS_pubmethodDispose()

Libère toutes les ressources utilisées par l'instance actuelle de la classe Task.

System_CAPS_protmethodDispose(Boolean)

Supprime la Task, en libérant toutes ses ressources non managées.

System_CAPS_pubmethodEquals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.(Hérité de Object.)

System_CAPS_protmethodFinalize()

Autorise un objet à tenter de libérer des ressources et d'exécuter d'autres opérations de nettoyage avant qu'il ne soit récupéré par l'opération garbage collection. (Hérité de Object.)

System_CAPS_pubmethodSystem_CAPS_staticFromCanceled(CancellationToken)

Crée une Task qui s'est terminée en raison de l'annulation avec un jeton d'annulation spécifié.

System_CAPS_pubmethodSystem_CAPS_staticFromCanceled<TResult>(CancellationToken)

Crée une Task<TResult> qui s'est terminée en raison de l'annulation avec un jeton d'annulation spécifié.

System_CAPS_pubmethodSystem_CAPS_staticFromException(Exception)

Crée une Task qui s'est terminée avec une exception spécifiée.

System_CAPS_pubmethodSystem_CAPS_staticFromException<TResult>(Exception)

Crée une Task<TResult> qui s'est terminée avec une exception spécifiée.

System_CAPS_pubmethodSystem_CAPS_staticFromResult<TResult>(TResult)

Crée une Task<TResult> qui s'est terminée correctement avec le résultat spécifié.

System_CAPS_pubmethodGetAwaiter()

Obtient un élément awaiter utilisé pour attendre cette Task.

System_CAPS_pubmethodGetHashCode()

Fait office de fonction de hachage par défaut. (Hérité de Object.)

System_CAPS_pubmethodGetType()

Obtient le Type de l'instance actuelle.(Hérité de Object.)

System_CAPS_protmethodMemberwiseClone()

Crée une copie superficielle du Object actuel.(Hérité de Object.)

System_CAPS_pubmethodSystem_CAPS_staticRun(Action)

Met en file d'attente le travail spécifié à exécuter dans le pool de threads et retourne un objet Task qui représente ce travail.

System_CAPS_pubmethodSystem_CAPS_staticRun(Action, CancellationToken)

Met en file d'attente le travail spécifié à exécuter dans le pool de threads et retourne un objet Task qui représente ce travail. Un jeton d’annulation permet l’annulation du travail.

System_CAPS_pubmethodSystem_CAPS_staticRun(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.

System_CAPS_pubmethodSystem_CAPS_staticRun(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.

System_CAPS_pubmethodSystem_CAPS_staticRun<TResult>(Func<TResult>)

Met en file d'attente le travail spécifié à exécuter dans le pool de threads et retourne un objet Task<TResult> qui représente ce travail.

System_CAPS_pubmethodSystem_CAPS_staticRun<TResult>(Func<TResult>, CancellationToken)

Met en file d'attente le travail spécifié à exécuter dans le pool de threads et retourne un objet Task(TResult) qui représente ce travail. Un jeton d’annulation permet l’annulation du travail.

System_CAPS_pubmethodSystem_CAPS_staticRun<TResult>(Func<Task<TResult>>)

Met en file d’attente le travail spécifié à exécuter dans le pool de threads et retourne un proxy pour le Task(TResult) retourné par function.

System_CAPS_pubmethodSystem_CAPS_staticRun<TResult>(Func<Task<TResult>>, CancellationToken)

Met en file d’attente le travail spécifié à exécuter dans le pool de threads et retourne un proxy pour le Task(TResult) retourné par function.

System_CAPS_pubmethodRunSynchronously()

Exécute de façon synchrone la Task sur le TaskScheduler actuel.

System_CAPS_pubmethodRunSynchronously(TaskScheduler)

Exécute de façon synchrone le Task sur le TaskScheduler fourni.

System_CAPS_pubmethodStart()

Démarre la Task, en planifiant son exécution selon le TaskScheduler actuel.

System_CAPS_pubmethodStart(TaskScheduler)

Démarre la Task, en planifiant son exécution sur le TaskScheduler spécifié.

System_CAPS_pubmethodToString()

Retourne une chaîne qui représente l'objet actuel.(Hérité de Object.)

System_CAPS_pubmethodWait()

Attend la fin de l'exécution de Task.

System_CAPS_pubmethodWait(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.

System_CAPS_pubmethodWait(Int32)

Attend la fin de l'exécution de la Task en un nombre de millisecondes spécifié.

System_CAPS_pubmethodWait(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.

System_CAPS_pubmethodWait(TimeSpan)

Attend la fin de l'exécution de la Task dans un intervalle de temps spécifié.

System_CAPS_pubmethodSystem_CAPS_staticWaitAll(Task[])

Attend la fin de l'exécution de tous les objets Task fournis.

System_CAPS_pubmethodSystem_CAPS_staticWaitAll(Task[], CancellationToken)

Attend la fin de l'exécution de tous les objets Task fournis sauf si l'attente est annulée.

System_CAPS_pubmethodSystem_CAPS_staticWaitAll(Task[], Int32)

Attend la fin de l'exécution de tous les objets Task fournis en un nombre de millisecondes spécifié.

System_CAPS_pubmethodSystem_CAPS_staticWaitAll(Task[], Int32, CancellationToken)

Attend la fin de l'exécution de tous les objets Task fournis en un nombre de millisecondes spécifié ou jusqu'à ce que l'attente soit annulée.

System_CAPS_pubmethodSystem_CAPS_staticWaitAll(Task[], TimeSpan)

Attend la fin de l'exécution de tous les objets Task pouvant être annulés fournis dans un intervalle de temps spécifié.

System_CAPS_pubmethodSystem_CAPS_staticWaitAny(Task[])

Attend la fin de l'exécution de l'un des objets Task fournis.

System_CAPS_pubmethodSystem_CAPS_staticWaitAny(Task[], CancellationToken)

Attend la fin de l'exécution de l'un des objets Task fournis sauf si l'attente est annulée.

System_CAPS_pubmethodSystem_CAPS_staticWaitAny(Task[], Int32)

Attend la fin de l'exécution de l'un des objets Task fournis en un nombre de millisecondes spécifié.

System_CAPS_pubmethodSystem_CAPS_staticWaitAny(Task[], Int32, CancellationToken)

Attend la fin de l'exécution de l'un des objets Task fournis en un nombre de millisecondes spécifié ou jusqu'à ce qu'un jeton d'annulation soit annulé.

System_CAPS_pubmethodSystem_CAPS_staticWaitAny(Task[], TimeSpan)

Attend la fin de l'exécution de n'importe lequel des objets Task fournis dans un intervalle de temps spécifié.

System_CAPS_pubmethodSystem_CAPS_staticWhenAll(IEnumerable<Task>)

Crée une tâche qui s'achève quand tous les objets Task d'une collection énumérable sont terminés.

System_CAPS_pubmethodSystem_CAPS_staticWhenAll(Task[])

Crée une tâche qui s'achève quand tous les objets Task d'un tableau sont terminés.

System_CAPS_pubmethodSystem_CAPS_staticWhenAll<TResult>(IEnumerable<Task<TResult>>)

Crée une tâche qui s'achève quand tous les objets Task<TResult> d'une collection énumérable sont terminés.

System_CAPS_pubmethodSystem_CAPS_staticWhenAll<TResult>(Task<TResult>[])

Crée une tâche qui s'achève quand tous les objets Task<TResult> d'un tableau sont terminés.

System_CAPS_pubmethodSystem_CAPS_staticWhenAny(IEnumerable<Task>)

Crée une tâche qui s'achève quand l'une des tâches fournies est terminée.

System_CAPS_pubmethodSystem_CAPS_staticWhenAny(Task[])

Crée une tâche qui s'achève quand l'une des tâches fournies est terminée.

System_CAPS_pubmethodSystem_CAPS_staticWhenAny<TResult>(IEnumerable<Task<TResult>>)

Crée une tâche qui s'achève quand l'une des tâches fournies est terminée.

System_CAPS_pubmethodSystem_CAPS_staticWhenAny<TResult>(Task<TResult>[])

Crée une tâche qui s'achève quand l'une des tâches fournies est terminée.

System_CAPS_pubmethodSystem_CAPS_staticYield()

Crée une tâche pouvant être attendue qui se produit de manière asynchrone dans le contexte actuel pendant l'attente.

NomDescription
System_CAPS_pubmethodDispatcherOperationWait()

Surchargé. Attend indéfiniment que l'opération DispatcherOperation sous-jacente se termine.(Défini par TaskExtensions.)

System_CAPS_pubmethodDispatcherOperationWait(TimeSpan)

Surchargé. Attend pendant le délai spécifié que le DispatcherOperation sous-jacente se termine.(Défini par TaskExtensions.)

System_CAPS_pubmethodIsDispatcherOperationTask()

Retourne une valeur qui indique si cette Task est associée à une DispatcherOperation.(Défini par TaskExtensions.)

System_CAPS_noteRemarque

Pour afficher le code source de .NET Framework pour ce type, consultez la Reference Source.Vous pouvez parcourir le code source en ligne, téléchargez la référence hors connexion et parcourir les sources (y compris les correctifs et mises à jour) au cours du débogage ; see instructions.

Le Task classe représente une opération unique qui ne retourne pas une valeur et qui généralement exécute de façon asynchrone. Task les objets sont parmi les composants centraux de la introduite dans .NET Framework 4.Étant donné que le travail effectué par un Task objet généralement exécute de façon asynchrone sur un thread de pool de threads plutôt que de façon synchrone sur le thread principal de l'application, vous pouvez utiliser la Status propriété, ainsi que le IsCanceled, IsCompleted, et IsFaulted Propriétés, pour déterminer l'état d'une tâche.Le plus souvent, une expression lambda est utilisée pour spécifier le travail à effectuer la tâche.

Task instances peuvent être créées de plusieurs façons.L'approche la plus courante, qui est disponible à partir du .NET Framework 4.5, consiste à appeler la méthode statique Run (méthode).Le Run méthode fournit un moyen simple de démarrer une tâche à l'aide des valeurs par défaut et sans nécessiter de paramètres supplémentaires.L'exemple suivant utilise le Run(Action) 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()
   {
      Task t = Task.Run( () => {
                                  // Just loop.
                                  int ctr = 0;
                                  for (ctr = 0; ctr <= 1000000; ctr++)
                                  {}
                                  Console.WriteLine("Finished {0} loop iterations",
                                                    ctr);
                               } );
      t.Wait();
   }
}
// The example displays the following output:
//        Finished 1000001 loop iterations

Une autre solution et la méthode la plus courante pour démarrer une tâche .NET Framework 4, est la méthode statique TaskFactory.StartNew (méthode).Le Task.Factory propriété retourne un TaskFactory objet.Les surcharges de la TaskFactory.StartNew méthode vous permettre de spécifier les paramètres à passer à un planificateur de tâches et les options de création de tâche.L'exemple suivant utilise le TaskFactory.StartNew méthode pour démarrer une tâche.Il est fonctionnellement équivalent au code dans l'exemple précédent.

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      Task t = Task.Factory.StartNew( () => {
                                  // Just loop.
                                  int ctr = 0;
                                  for (ctr = 0; ctr <= 1000000; ctr++)
                                  {}
                                  Console.WriteLine("Finished {0} loop iterations",
                                                    ctr);
                               } );
      t.Wait();
   }
}
// The example displays the following output:
//        Finished 1000001 loop iterations

Pour obtenir des exemples plus complets, consultez Parallélisme des tâches (bibliothèque parallèle de tâches).

Le Task 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, le Task.Run ou TaskFactory.StartNew méthode est le mécanisme par défaut pour la création et la planification des tâches de calcul, mais pour les scénarios où la création et la planification doivent être séparés, vous pouvez utiliser les constructeurs et ensuite appeler la Task.Start méthode pour planifier la tâche pour l'exécution à un moment ultérieur.

À partir des applications de bureau qui ciblent le .NET Framework 4.6, la culture du thread qui crée et appelle une tâche devient partie intégrante du contexte du thread.Autrement dit, indépendamment de 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 à la .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 reposant sur une tâche » dans la CultureInfo rubrique.Notez que les applications du Windows Store suivent le Windows Runtime dans la définition et l'obtention de la culture par défaut.

Pour les opérations qui retournent des valeurs, vous utilisez la Task<TResult> classe.

Pour les développeurs implémentent des débogueurs personnalisés, plusieurs membres internes et privés de tâche peuvent être utiles (ils peuvent varier d'une version à l'autre).Le m_taskId champ sert de magasin de stockage pour le Id propriété, toutefois l'accès à ce champ directement à partir d'un débogueur peut être plus efficace que l'accès à la même valeur via la méthode d'accesseur Get de la propriété (la s_taskIdCounter compteur permet de récupérer le prochain ID disponible pour une tâche).De même, le m_stateFlags champ stocke des informations sur l'étape du cycle de vie actuel de la tâche, informations également accessibles via la Status propriété.Le m_action champ stocke une référence au délégué de la tâche et le m_stateObject champ stocke l'état asynchrone passé à la tâche par le développeur.Enfin, pour les débogueurs qui analysent des frames de pile, le InternalWait méthode sert un marqueur potentiel pour une tâche entre lorsqu'une opération d'attente.

L'exemple suivant crée et exécute des quatre tâches.Trois tâches exécutent un Action<T> délégué nommé action, qui accepte un argument de type Object.Une quatrième tâche exécute une expression lambda (un Action délégué) qui est défini inline dans l'appel à la méthode de création de tâche.Chaque tâche est instancié et exécuté de façon différente :

  • Tâche t1 est instancié en appelant un constructeur de classe de tâche, mais est démarré en appelant son Start() méthode uniquement après la tâche t2 a démarré.

  • Tâche t2 est instancié et démarré dans un seul appel de méthode en appelant le TaskFactory.StartNew(Action<Object>, Object) (méthode).

  • Tâche t3 est instancié et démarré dans un seul appel de méthode en appelant le Run(Action) (méthode).

  • Tâche t4 est exécutée de façon synchrone sur le thread principal en appelant le RunSynchronously() (méthode).

Étant donné que tâche t4 exécute de façon synchrone, il s'exécute sur le thread d'application principal.Les tâches restantes exécutent de façon asynchrone en général sur un ou plusieurs threads du pool.

using System;
using System.Threading;
using System.Threading.Tasks;

class Example
{
    static void Main()
    {
        Action<object> action = (object obj) =>
                                {
                                   Console.WriteLine("Task={0}, obj={1}, Thread={2}",
                                   Task.CurrentId, obj,
                                   Thread.CurrentThread.ManagedThreadId);
                                };

        // Create a task but do not start it.
        Task t1 = new Task(action, "alpha");

        // Construct a started task
        Task t2 = Task.Factory.StartNew(action, "beta");
        // Block the main thread to demonstate that t2 is executing
        t2.Wait();

        // Launch t1 
        t1.Start();
        Console.WriteLine("t1 has been launched. (Main Thread={0})",
                          Thread.CurrentThread.ManagedThreadId);
        // Wait for the task to finish.
        t1.Wait();

        // Construct a started task using Task.Run.
        String taskData = "delta";
        Task t3 = Task.Run( () => {Console.WriteLine("Task={0}, obj={1}, Thread={2}",
                                                     Task.CurrentId, taskData,
                                                      Thread.CurrentThread.ManagedThreadId);
                                   });
        // Wait for the task to finish.
        t3.Wait();

        // Construct an unstarted task
        Task t4 = new Task(action, "gamma");
        // Run it synchronously
        t4.RunSynchronously();
        // Although the task was run synchronously, it is a good practice
        // to wait for it in the event exceptions were thrown by the task.
        t4.Wait();
    }
}
// The example displays output like the following:
//       Task=1, obj=beta, Thread=3
//       t1 has been launched. (Main Thread=1)
//       Task=2, obj=alpha, Thread=4
//       Task=3, obj=delta, Thread=3
//       Task=4, obj=gamma, Thread=1

Universal Windows Platform
Disponible depuis 4.5
.NET Framework
Disponible depuis 4.0
Portable Class Library
Pris en charge dans : portable .NET platforms
Silverlight
Disponible depuis 5.0
Windows Phone Silverlight
Disponible depuis 8.0
Windows Phone
Disponible depuis 8.1

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

Retour au début
Afficher:
© 2016 Microsoft