Task.RunSynchronously Méthode

Définition

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

Surcharges

RunSynchronously()

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

RunSynchronously(TaskScheduler)

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

RunSynchronously()

Exécute de façon synchrone la Task sur le TaskScheduler actuel.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 la RunSynchronously méthode avec une tâche exécutée 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 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.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 million.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 la 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. Les tâches exécutées en appelant la RunSynchronously() méthode sont associées au en cours TaskScheduler et sont exécutées 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 l’exécution de cette tâche sur le thread appelant, la tâche est planifiée pour être exécutée sur le planificateur et le thread appelant se bloque jusqu’à la fin de l’exécution de la tâche.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 toutes les exceptions que la tâche peut lever.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.

Les tâches exécutées en appelant la RunSynchronously méthode sont instanciées en appelant un Task constructeur de Task<TResult> classe ou.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 l' 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 une seule fois.A task may be started and run only once. Toute tentative de planification d’une tâche entraîne une exception.Any attempts to schedule a task a second time results in an exception.

Voir aussi

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

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

Les tâches exécutées en appelant la méthode RunSynchronously sont instanciées en appelant un constructeur de classe Task ou Task<TResult> .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 l' 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 une seule fois.A task may be started and run only once. Toute tentative de planification d’une tâche 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 l’exécution de cette tâche sur le thread actuel, la tâche est planifiée pour être exécutée sur le planificateur et le thread actuel est bloqué jusqu’à la fin de l’exécution de la tâche.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 n’a pas besoin d’appeler une méthode telle que Wait pour s’assurer que la tâche a terminé 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 à