Task.RunSynchronously Methode

Definition

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()

Führt den Task synchron mit dem aktuellen TaskScheduler aus.

public:
 void RunSynchronously();
public void RunSynchronously ();
member this.RunSynchronously : unit -> unit
Public 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 RunSynchronously Methode asynchron ausgeführt wird. In beiden Fällen führen die Aufgaben identische Lambdaausdrücke aus, die die Vorgangs-ID und die ID des Threads anzeigen, auf dem die Aufgabe ausgeführt wird. Der Vorgang berechnet die Summe der Ganzzahlen zwischen 1 und 1.000.000. Wie die Ausgabe aus dem Beispiel gezeigt wird, wird die aufgabe ausgeführt, indem die RunSynchronously Methode im Anwendungsthread aufgerufen 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
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

Ordinarily werden Aufgaben asynchron in einem Threadpoolthread ausgeführt und blockieren nicht den aufrufenden Thread. Aufgaben, die durch Aufrufen der RunSynchronously() Methode ausgeführt werden, sind dem aktuellen TaskScheduler zugeordnet und werden auf dem aufrufenden Thread ausgeführt. Wenn der Zielplaner die Ausführung dieses Vorgangs auf dem aufrufenden Thread nicht unterstützt, wird der Vorgang für die Ausführung des Zeitplans geplant, und der aufrufende Thread wird blockiert, bis die Ausführung des Vorgangs abgeschlossen wurde. Obwohl die Aufgabe synchron ausgeführt wird, sollte der aufrufende Thread weiterhin aufgerufen Wait werden, um ausnahmen zu behandeln, die der Vorgang auslösen kann. Weitere Informationen zur Ausnahmebehandlung finden Sie unter "Ausnahmebehandlung".

Aufgaben, die durch Aufrufen der RunSynchronously Methode ausgeführt werden, werden durch Aufrufen eines Task oder Task<TResult> Klassenkonstruktors instanziiert. Die synchrone Ausführung der 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.

Siehe auch

Gilt für:

RunSynchronously(TaskScheduler)

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 -> unit
Public 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 oder Task<TResult> Klassenkonstruktors instanziiert. Die synchrone Ausführung der 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 dieses Vorgangs im aktuellen Thread nicht unterstützt, wird der Vorgang für die Ausführung des Zeitplans geplant, und der aktuelle Thread blockiert, bis die Ausführung des Vorgangs abgeschlossen wurde. Aus diesem Gründen muss der aufrufende Thread keine Methode aufrufen, z Wait . B. um sicherzustellen, dass die Ausführung der Aufgabe abgeschlossen wurde. Weitere Informationen zur Ausnahmebehandlung für Vorgangsvorgänge finden Sie unter "Ausnahmebehandlung".

Siehe auch

Gilt für: