Task.RunSynchronously Méthode
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
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 -> unitPublic 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 -> unitPublic 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.
