Partager via


Task.RunSynchronously Méthode

Définition

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

Surcharges

RunSynchronously()

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

RunSynchronously(TaskScheduler)

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

RunSynchronously()

Source:
Task.cs
Source:
Task.cs
Source:
Task.cs

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

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

Exceptions

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

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.

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 manière 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 la RunSynchronously méthode s’exécute sur le thread d’application, contrairement à 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
open System
open System.Threading
open System.Threading.Tasks

printfn $"Application executing on thread {Thread.CurrentThread.ManagedThreadId}"

let asyncTask =
    Task.Run(fun () ->
        printfn $"Task {Task.CurrentId} (asyncTask) executing on Thread {Thread.CurrentThread.ManagedThreadId}"
        let mutable sum = 0L

        for i = 1 to 1000000 do
            sum <- sum + int64 i

        sum)

let syncTask =
    new Task<int64>(fun () ->
        printfn $"Task {Task.CurrentId} (syncTask) executing on Thread {Thread.CurrentThread.ManagedThreadId}"
        let mutable sum = 0L

        for i = 1 to 1000000 do
            sum <- sum + int64 i

        sum)

syncTask.RunSynchronously()
printfn $"\nTask {syncTask.Id} returned {syncTask.Result:N0}"
printfn $"Task {asyncTask.Id} returned {asyncTask.Result:N0}"

// 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 manière asynchrone sur un thread de pool de threads et ne bloquent pas le thread appelant. Les tâches exécutées en appelant la RunSynchronously() méthode sont associées au actuel TaskScheduler et sont exécutées sur le thread appelant. Si le planificateur cible ne prend pas en charge l’exécution de cette tâche sur le thread appelant, l’exécution de la tâche est planifiée sur le planificateur et le thread appelant se bloque jusqu’à ce que l’exécution de la tâche soit terminée. Même si la tâche s’exécute de manière synchrone, le thread appelant doit toujours appeler Wait pour gérer les exceptions que la tâche peut lever. Pour plus d’informations sur la gestion des exceptions, consultez Gestion des exceptions.

Les tâches exécutées en appelant la RunSynchronously méthode sont instanciées en appelant un Task constructeur de classe ou Task<TResult> . La tâche à exécuter de manière synchrone doit être dans l’état Created . Une tâche ne peut être démarrée et exécutée qu’une seule fois. Toute tentative de planification d’une tâche une deuxième fois entraîne une exception.

Voir aussi

S’applique à

RunSynchronously(TaskScheduler)

Source:
Task.cs
Source:
Task.cs
Source:
Task.cs

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

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.

Exceptions

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

L'argument scheduler a la valeur null.

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.

Remarques

Les tâches exécutées en appelant la RunSynchronously méthode sont instanciées en appelant un Task constructeur de classe ou Task<TResult> . La tâche à exécuter de manière synchrone doit être dans l’état Created . Une tâche ne peut être démarrée et exécutée qu’une seule fois. Toute tentative de planification d’une tâche une deuxième fois entraîne une exception.

Si le planificateur cible ne prend pas en charge l’exécution de cette tâche sur le thread actuel, l’exécution de la tâche est planifiée sur le planificateur et le thread actuel se bloque jusqu’à ce que l’exécution de la tâche soit terminée. Pour cette raison, le thread appelant n’a pas besoin d’appeler une méthode telle que Wait pour s’assurer que l’exécution de la tâche est terminée. Pour plus d’informations sur la gestion des exceptions pour les opérations de tâche, consultez Gestion des exceptions.

Voir aussi

S’applique à