Task.RunSynchronously Methode

Definition

Namespace:
System.Threading.Tasks
Assemblys:
mscorlib.dll, System.Threading.Tasks.dll
Assembly:
mscorlib.dll
Assembly:
System.Threading.Tasks.dll
Assembly:
netstandard.dll

Führt die Task synchrone Ausführung auf dem aktuellen TaskScheduler.

Überlädt

Name Beschreibung
RunSynchronously()

Führt die Task synchrone Ausführung auf dem aktuellen TaskScheduler.
RunSynchronously(TaskScheduler)

Führt die Task synchrone Ausführung für die TaskScheduler bereitgestellte Funktion aus.

RunSynchronously()

Führt die Task synchrone Ausführung auf dem aktuellen TaskScheduler.

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

Ausnahmen

ObjectDisposedException

Die Task Instanz wurde verworfen.

InvalidOperationException

Dies Task ist nicht in einem gültigen Zustand, der gestartet werden soll. Es wurde möglicherweise bereits gestartet, ausgeführt oder abgebrochen, oder es wurde auf eine Weise erstellt, die die direkte Planung nicht unterstützt.

Beispiele

Im folgenden Beispiel wird eine Aufgabe verglichen, die ausgeführt wird, indem die RunSynchronously Methode asynchron mit einer ausgeführt wird. In beiden Fällen führen die Aufgaben identische Lambda-Ausdrücke aus, die die Aufgaben-ID und die ID des Threads anzeigen, auf dem die Aufgabe ausgeführt wird. Der Vorgang berechnet die Summe der ganzen Zahlen zwischen 1 und 1.000.000. Wie die Ausgabe aus dem Beispiel zeigt, wird die Aufgabe ausgeführt, die durch Aufrufen der RunSynchronously Methode im Anwendungsthread ausgeführt wird, während die asynchrone Aufgabe nicht ausgeführt wird.

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 asynchron in einem Threadpoolthread 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 Aufgabe für die Ausführung im Scheduler geplant, und der aufrufende Thread wird blockiert, bis die Ausführung der Aufgabe abgeschlossen ist. Obwohl die Aufgabe synchron ausgeführt wird, sollte der aufrufende Thread weiterhin aufgerufen Wait werden, um ausnahmen zu behandeln, die von der Aufgabe ausgelöst werden können. Weitere Informationen zur Ausnahmebehandlung finden Sie unter "Ausnahmebehandlung".

Durch Aufrufen der RunSynchronously Methode ausgeführte Aufgaben werden durch Aufrufen eines Task Klassenkonstruktors Task<TResult> instanziiert. Die synchron auszuführende Aufgabe muss sich Created im Zustand befinden. Eine Aufgabe kann nur einmal gestartet und ausgeführt werden. Alle Versuche, einen Vorgang ein zweites Mal zu planen, führt zu einer Ausnahme.

Weitere Informationen

Gilt für:

RunSynchronously(TaskScheduler)

Führt die Task synchrone Ausführung für die TaskScheduler bereitgestellte Funktion aus.

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)

Parameter

scheduler
TaskScheduler

Der Zeitplan, für den versucht werden soll, diese Aufgabe inline auszuführen.

Ausnahmen

ObjectDisposedException

Die Task Instanz wurde verworfen.

ArgumentNullException

Das scheduler Argument ist null.

InvalidOperationException

Dies Task ist nicht in einem gültigen Zustand, der gestartet werden soll. Es wurde möglicherweise bereits gestartet, ausgeführt oder abgebrochen, oder es wurde auf eine Weise erstellt, die die direkte Planung nicht unterstützt.

Hinweise

Durch Aufrufen der RunSynchronously Methode ausgeführte Aufgaben werden durch Aufrufen eines Task Klassenkonstruktors Task<TResult> instanziiert. Die synchron auszuführende Aufgabe muss sich Created im Zustand befinden. Eine Aufgabe kann nur einmal gestartet und ausgeführt werden. Alle Versuche, einen Vorgang ein zweites Mal zu planen, führt zu einer Ausnahme.

Wenn der Zielplaner die Ausführung dieser Aufgabe im aktuellen Thread nicht unterstützt, wird die Aufgabe für die Ausführung im Scheduler geplant, und der aktuelle Thread wird blockiert, bis die Ausführung der Aufgabe abgeschlossen ist. Aus diesem Gründen muss der aufrufende Thread keine Methode aufrufen, z Wait . B. um sicherzustellen, dass die Aufgabe die Ausführung abgeschlossen hat. Weitere Informationen zur Ausnahmebehandlung für Vorgangsvorgänge finden Sie unter "Ausnahmebehandlung".

Weitere Informationen

Gilt für: