Task.RunSynchronously Task.RunSynchronously Task.RunSynchronously Task.RunSynchronously Method

Définition

Exécute de façon synchrone la Task sur le TaskScheduler en cours.Runs the Task synchronously on the current TaskScheduler.

Surcharges

RunSynchronously() RunSynchronously() RunSynchronously() RunSynchronously()

Exécute de façon synchrone la Task sur le TaskScheduler en cours.Runs the Task synchronously on the current TaskScheduler.

RunSynchronously(TaskScheduler) RunSynchronously(TaskScheduler) RunSynchronously(TaskScheduler) RunSynchronously(TaskScheduler)

Exécute de façon synchrone le Task sur le TaskScheduler fourni.Runs the Task synchronously on the TaskScheduler provided.

RunSynchronously() RunSynchronously() RunSynchronously() RunSynchronously()

Exécute de façon synchrone la Task sur le TaskScheduler en cours.Runs the Task synchronously on the current TaskScheduler.

public:
 void RunSynchronously();
public void RunSynchronously ();
member this.RunSynchronously : unit -> unit
Public Sub RunSynchronously ()

Exceptions

L’instance Task a été supprimée.The Task instance has been disposed.

La Task n’est pas dans un état valide pour être démarrée.The Task is not in a valid state to be started. 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.It may have already been started, executed, or canceled, or it may have been created in a manner that doesn't support direct scheduling.

Exemples

L’exemple suivant compare une tâche exécutée en appelant le RunSynchronously méthode avec un exécutées de façon asynchrone.The following example compares a task executed by calling the RunSynchronously method with one executed asynchronously. Dans les deux cas, les tâches s’exécutent les expressions lambda identiques qui affichent l’ID de tâche et l’ID du thread sur lequel la tâche s’exécute.In both cases, the tasks execute identical lambda expressions that display the task ID and the ID of the thread on which the task is running. La tâche calcule la somme des entiers compris entre 1 et 1 000 000.The task calculates the sum of the integers between 1 and 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, contrairement à la tâche asynchrone.As the output from the example shows, the task executed by calling the RunSynchronously method runs on the application thread, while the asynchronous task does not.

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
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Console.WriteLine("Application executing on thread {0}",
                        Thread.CurrentThread.ManagedThreadId)
      Dim asyncTask = Task.Run( Function()
                                   Console.WriteLine("Task {0} (asyncTask) executing on Thread {1}",
                                                     Task.CurrentId,
                                                     Thread.CurrentThread.ManagedThreadId)
                                   Dim sum As Long = 0
                                   For ctr As Integer = 1 To 1000000
                                      sum += ctr
                                   Next
                                   Return sum
                                End Function)
      Dim syncTask As New Task(Of Long)( Function()
                                            Console.WriteLine("Task {0} (syncTask) executing on Thread {1}",
                                                              Task.CurrentId,
                                                              Thread.CurrentThread.ManagedThreadId)
                                            Dim sum As Long = 0
                                            For ctr As Integer = 1 To 1000000
                                               sum += ctr
                                            Next
                                            Return sum
                                         End Function)
      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)
   End Sub
End Module
' 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

Remarques

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.Ordinarily, tasks are executed asynchronously on a thread pool thread and do not block the calling thread. Tâches exécutées en appelant le RunSynchronously() méthode associés actuel TaskScheduler et sont exécutés sur le thread appelant.Tasks executed by calling the RunSynchronously() method are associated with the current TaskScheduler and are run on the calling thread. 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 s’exécuter sur le planificateur et bloque le thread appelant jusqu'à ce que la tâche a terminé son exécution.If the target scheduler does not support running this task on the calling thread, the task will be scheduled for execution on the scheduler, and the calling thread will block until the task has completed execution. Même si 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.Even though the task runs synchronously, the calling thread should still call Wait to handle any exceptions that the task might throw. Pour plus d’informations sur la gestion des exceptions, consultez gestion des exceptions.For more information on exception handling, see Exception Handling.

Tâches exécutées en appelant le RunSynchronously méthode sont instanciés en appelant un Task ou Task<TResult> constructeur de classe.Tasks executed by calling the RunSynchronously method are instantiated by calling a Task or Task<TResult> class constructor. La tâche à exécuter de façon synchrone doit être dans le Created état.The task to be run synchronously must be in the Created state. Une tâche peut être démarrée et exécutée qu’une seule fois.A task may be started and run only once. Toute tentative pour planifier une tâche une deuxième fois entraîne une exception.Any attempts to schedule a task a second time results in an exception.

Voir aussi

RunSynchronously(TaskScheduler) RunSynchronously(TaskScheduler) RunSynchronously(TaskScheduler) RunSynchronously(TaskScheduler)

Exécute de façon synchrone le Task sur le TaskScheduler fourni.Runs the Task synchronously on the TaskScheduler provided.

public:
 void RunSynchronously(System::Threading::Tasks::TaskScheduler ^ scheduler);
public void RunSynchronously (System.Threading.Tasks.TaskScheduler scheduler);
member this.RunSynchronously : System.Threading.Tasks.TaskScheduler -> unit
Public Sub RunSynchronously (scheduler As TaskScheduler)

Paramètres

scheduler
TaskScheduler TaskScheduler TaskScheduler TaskScheduler

Planificateur sur lequel tenter d'exécuter cette tâche inline.The scheduler on which to attempt to run this task inline.

Exceptions

L’instance Task a été supprimée.The Task instance has been disposed.

L'argument scheduler a la valeur null.The scheduler argument is null.

La Task n’est pas dans un état valide pour être démarrée.The Task is not in a valid state to be started. 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.It may have already been started, executed, or canceled, or it may have been created in a manner that doesn't support direct scheduling.

Remarques

Tâches exécutées en appelant le RunSynchronously méthode sont instanciés en appelant un Task ou Task<TResult> constructeur de classe.Tasks executed by calling the RunSynchronously method are instantiated by calling a Task or Task<TResult> class constructor. La tâche à exécuter de façon synchrone doit être dans le Created état.The task to be run synchronously must be in the Created state. Une tâche peut être démarrée et exécutée qu’une seule fois.A task may be started and run only once. Toute tentative pour planifier une tâche une deuxième fois entraîne une exception.Any attempts to schedule a task a second time results in an exception.

Si le planificateur cible ne prend pas en charge cette tâche en cours d’exécution sur le thread actuel, la tâche sera planifiée pour s’exécuter sur le planificateur et bloque le thread actuel jusqu'à ce que la tâche a terminé son exécution.If the target scheduler does not support running this task on the current thread, the task will be scheduled for execution on the scheduler, and the current thread will block until the task has completed execution. Pour cette raison, le thread appelant est inutile d’appeler une méthode telle que Wait pour vous assurer que la tâche de fin de l’exécution.Because of this, the calling thread does not need to call a method such as Wait to ensure that the task has completed execution. Pour plus d’informations sur la gestion des exceptions pour les opérations de tâche, consultez gestion des exceptions.For more information on exception handling for task operations, see Exception Handling.

Voir aussi

S’applique à