Task.RunSynchronously Méthode

Définition

Espace de noms:
System.Threading.Tasks
Assemblys:
mscorlib.dll, System.Threading.Tasks.dll
Assembly:
mscorlib.dll
Assembly:
System.Threading.Tasks.dll
Assembly:
netstandard.dll

S’exécute Task de manière synchrone sur le fichier actif TaskScheduler.

Surcharges

Nom Description
RunSynchronously()

S’exécute Task de manière synchrone sur le fichier actif TaskScheduler.
RunSynchronously(TaskScheduler)

Exécute la Task synchronisation sur l’élément TaskScheduler fourni.

RunSynchronously()

S’exécute Task de manière synchrone sur le fichier actif TaskScheduler.

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

Exceptions

ObjectDisposedException

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

InvalidOperationException

L’état Task n’est pas valide à démarrer. Elle a peut-être déjà été démarrée, exécutée ou annulée, ou elle a peut-être été 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 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 est en cours d’exécution. 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, tandis que la tâche asynchrone ne le fait pas.

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 courant 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, la tâche est planifiée pour l’exécution sur le planificateur et le thread appelant se bloque tant que la tâche n’a pas terminé l’exécution. 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 constructeur ou Task<TResult> un Task constructeur de classe. La tâche à exécuter de manière synchrone doit être dans l’état Created . Une tâche peut être démarrée et exécutée 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)

Exécute la Task synchronisation sur l’élément 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

ObjectDisposedException

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

ArgumentNullException

L’argument scheduler est null.

InvalidOperationException

L’état Task n’est pas valide à démarrer. Elle a peut-être déjà été démarrée, exécutée ou annulée, ou elle a peut-être été 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 constructeur ou Task<TResult> un Task constructeur de classe. La tâche à exécuter de manière synchrone doit être dans l’état Created . Une tâche peut être démarrée et exécutée 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 actif, la tâche est planifiée pour l’exécution sur le planificateur et le thread actuel bloque tant que la tâche n’a pas terminé l’exécution. En raison de cela, 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. Pour plus d’informations sur la gestion des exceptions pour les opérations de tâche, consultez Gestion des exceptions.

Voir aussi

S’applique à