Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

Task.RunSynchronously méthode ()

 

Date de publication : novembre 2016

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

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

public void RunSynchronously()

Exception Condition
ObjectDisposedException

L’instance Task a été supprimée.

InvalidOperationException

La Task n’est pas dans un état valide pour être démarrée. Elle peut avoir déjà été démarrée, exécutée ou annulée, ou créée d’une manière qui ne prend pas en charge la planification directe.

En règle générale, les tâches sont exécutées de façon asynchrone sur un thread de pool de threads et ne bloquent pas le thread appelant. Les tâches exécutées en appelant le RunSynchronously() méthode associés actuel TaskScheduler et sont exécutées sur le thread appelant. Si le planificateur cible ne prend pas en charge cette tâche en cours d’exécution sur le thread appelant, la tâche sera planifiée pour une exécution sur le planificateur et bloque le thread appelant jusqu'à ce que la tâche a terminé son exécution. Bien que la tâche s’exécute de façon synchrone, le thread appelant doit toujours appeler Wait pour gérer les exceptions susceptibles de lever la tâche. Pour plus d’informations sur la gestion des exceptions, consultez Gestion des exceptions (bibliothèque parallèle de tâches).

Les tâches exécutées en appelant le RunSynchronously méthode sont instanciés en appelant un Task ou Task<TResult> constructeur de classe. La tâche à être exécutée de façon synchrone doit être dans la TaskStatus.Created état. Une tâche peut être démarrée et exécutée une seule fois. Toute tentative de planifier une tâche une deuxième instant précis entraîne une exception.

L’exemple suivant compare une tâche exécutée en appelant le RunSynchronously méthode avec une exécution asynchrone. Dans les deux cas, les tâches exécutent des expressions lambda identiques qui affichent l’ID de tâche et l’ID du thread sur lequel la tâche s’exécute. La tâche calcule la somme des entiers compris entre 1 et 1 000 000. Comme le montre la sortie de l’exemple, la tâche exécutée en appelant le RunSynchronously méthode s’exécute sur le thread d’application n’est pas le cas de la tâche asynchrone.

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

public class Example
{
   public static void Main()
   {
      Console.WriteLine("Application executing on thread {0}",
                        Thread.CurrentThread.ManagedThreadId);
      var asyncTask = Task.Run( () => {  Console.WriteLine("Task {0} (asyncTask) executing on Thread {1}",
                                                           Task.CurrentId,
                                                           Thread.CurrentThread.ManagedThreadId);
                                         long sum = 0;
                                         for (int ctr = 1; ctr <= 1000000; ctr++ )
                                            sum += ctr;
                                         return sum;
                                      });
      var syncTask = new Task<long>( () =>  { Console.WriteLine("Task {0} (syncTask) executing on Thread {1}",
                                                                 Task.CurrentId,
                                                                 Thread.CurrentThread.ManagedThreadId);
                                              long sum = 0;
                                              for (int ctr = 1; ctr <= 1000000; ctr++ )
                                                 sum += ctr;
                                              return sum;
                                            });
      syncTask.RunSynchronously();
      Console.WriteLine();
      Console.WriteLine("Task {0} returned {1:N0}", syncTask.Id, syncTask.Result);
      Console.WriteLine("Task {0} returned {1:N0}", asyncTask.Id, asyncTask.Result);
   }
}
// The example displays the following output:
//       Application executing on thread 1
//       Task 1 (syncTask) executing on Thread 1
//       Task 2 (asyncTask) executing on Thread 3
//       1 status: RanToCompletion
//       2 status: RanToCompletion
//
//       Task 2 returned 500,000,500,000
//       Task 1 returned 500,000,500,000

Plateforme Windows universelle
Disponible depuis 8
.NET Framework
Disponible depuis 4.0
Bibliothèque de classes portable
Pris en charge dans : plateformes .NET portables
Silverlight
Disponible depuis 5.0
Silverlight pour Windows Phone
Disponible depuis 8.0
Windows Phone
Disponible depuis 8.1
Retour au début
Afficher: