Task.RunSynchronously Methode
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Führt den Task synchron mit dem aktuellen TaskScheduler aus.
Überlädt
| RunSynchronously() |
Führt den Task synchron mit dem aktuellen TaskScheduler aus. |
| RunSynchronously(TaskScheduler) |
Führt die Task synchron mit dem bereitgestellten TaskScheduler aus. |
RunSynchronously()
- Quelle:
- Task.cs
- Quelle:
- Task.cs
- Quelle:
- Task.cs
Führt den Task synchron mit dem aktuellen TaskScheduler aus.
public:
void RunSynchronously();public void RunSynchronously ();member this.RunSynchronously : unit -> unitPublic Sub RunSynchronously ()Ausnahmen
Die Task-Instanz wurde verworfen.
Die Task liegt nicht in einem gültigen Zustand vor, um gestartet werden zu können. Möglicherweise wurde sie bereits gestartet, ausgeführt oder abgebrochen, oder sie wurde möglicherweise auf eine Weise erstellt, die keine direkte Planung unterstützt.
Beispiele
Im folgenden Beispiel wird eine Aufgabe verglichen, die durch Aufrufen der -Methode ausgeführt wird, mit einer Aufgabe, die RunSynchronously asynchron ausgeführt wird. In beiden Fällen führen die Tasks identische Lambdaausdrücke aus, die die Aufgaben-ID und die ID des Threads anzeigen, auf dem der Task ausgeführt wird. Der Task berechnet die Summe der ganzen Zahlen zwischen 1 und 1.000.000. Wie die Ausgabe aus dem Beispiel zeigt, wird die aufgabe, die durch aufrufen der RunSynchronously -Methode ausgeführt wird, im Anwendungsthread ausgeführt, während die asynchrone Aufgabe dies nicht tut.
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
Hinweise
Normalerweise werden Aufgaben in einem Threadpoolthread asynchron ausgeführt und blockieren den aufrufenden Thread nicht. Aufgaben, die durch aufrufen der RunSynchronously() -Methode ausgeführt werden, sind dem aktuellen TaskScheduler zugeordnet und werden im aufrufenden Thread ausgeführt. Wenn der Zielplaner die Ausführung dieser Aufgabe im aufrufenden Thread nicht unterstützt, wird die Ausführung des Tasks auf dem Planer geplant, und der aufrufende Thread blockiert, bis die Ausführung der Aufgabe abgeschlossen ist. Auch wenn der Task synchron ausgeführt wird, sollte der aufrufende Thread dennoch aufrufen Wait , um alle Ausnahmen zu behandeln, die der Task möglicherweise auslöst. Weitere Informationen zur Ausnahmebehandlung finden Sie unter Ausnahmebehandlung.
Aufgaben, die durch aufrufen der RunSynchronously -Methode ausgeführt werden, werden durch Aufrufen eines Task Klassenkonstruktors oder Task<TResult> instanziiert. Die aufgabe, die synchron ausgeführt werden soll, muss sich Created im Zustand befinden. Eine Aufgabe kann nur einmal gestartet und ausgeführt werden. Alle Versuche, eine Aufgabe ein zweites Mal zu planen, führen zu einer Ausnahme.
Weitere Informationen
Gilt für:
RunSynchronously(TaskScheduler)
- Quelle:
- Task.cs
- Quelle:
- Task.cs
- Quelle:
- Task.cs
Führt die Task synchron mit dem bereitgestellten TaskScheduler aus.
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)Parameter
- scheduler
- TaskScheduler
Der Taskplaner, mit dem diese Aufgabe inline ausgeführt werden soll.
Ausnahmen
Die Task-Instanz wurde verworfen.
Das scheduler-Argument lautet null.
Die Task liegt nicht in einem gültigen Zustand vor, um gestartet werden zu können. Möglicherweise wurde sie bereits gestartet, ausgeführt oder abgebrochen, oder sie wurde möglicherweise auf eine Weise erstellt, die keine direkte Planung unterstützt.
Hinweise
Aufgaben, die durch aufrufen der RunSynchronously -Methode ausgeführt werden, werden durch Aufrufen eines Task Klassenkonstruktors oder Task<TResult> instanziiert. Die aufgabe, die synchron ausgeführt werden soll, muss sich Created im Zustand befinden. Eine Aufgabe kann nur einmal gestartet und ausgeführt werden. Alle Versuche, eine Aufgabe ein zweites Mal zu planen, führen zu einer Ausnahme.
Wenn der Zielplaner die Ausführung dieser Aufgabe im aktuellen Thread nicht unterstützt, wird die Ausführung des Tasks auf dem Planer geplant, und der aktuelle Thread wird blockiert, bis die Ausführung der Aufgabe abgeschlossen ist. Aus diesem Fall muss der aufrufende Thread keine Methode aufrufen, z Wait . B. um sicherzustellen, dass die Ausführung des Tasks abgeschlossen wurde. Weitere Informationen zur Ausnahmebehandlung für Aufgabenvorgänge finden Sie unter Ausnahmebehandlung.
