Task.RunSynchronously Task.RunSynchronously Task.RunSynchronously Task.RunSynchronously Method

Definition

Führt den Task synchron mit dem aktuellen TaskScheduler aus.Runs the Task synchronously on the current TaskScheduler.

Überlädt

RunSynchronously() RunSynchronously() RunSynchronously() RunSynchronously()

Führt den Task synchron mit dem aktuellen TaskScheduler aus.Runs the Task synchronously on the current TaskScheduler.

RunSynchronously(TaskScheduler) RunSynchronously(TaskScheduler) RunSynchronously(TaskScheduler) RunSynchronously(TaskScheduler)

Führt die Task synchron mit dem bereitgestellten TaskScheduler aus.Runs the Task synchronously on the TaskScheduler provided.

RunSynchronously() RunSynchronously() RunSynchronously() RunSynchronously()

Führt den Task synchron mit dem aktuellen TaskScheduler aus.Runs the Task synchronously on the current TaskScheduler.

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

Ausnahmen

Die Task-Instanz wurde verworfen.The Task instance has been disposed.

Die Task liegt nicht in einem gültigen Zustand vor, um gestartet werden zu können.The Task is not in a valid state to be started. 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.It may have already been started, executed, or canceled, or it may have been created in a manner that doesn't support direct scheduling.

Beispiele

Im folgenden Beispiel wird eine Aufgabe verglichen, die ausgeführt wird, indem die RunSynchronously-Methode aufgerufen wird, die asynchron ausgeführt wird.The following example compares a task executed by calling the RunSynchronously method with one executed asynchronously. In beiden Fällen führen die Tasks identische Lambda-Ausdrücke aus, die die Task-ID und die ID des Threads, in dem der Task ausgeführt wird, anzeigen.In both cases, the tasks execute identical lambda expressions that display the task ID and the ID of the thread on which the task is running. Der Task berechnet die Summe der ganzen Zahlen zwischen 1 und 1 Million.The task calculates the sum of the integers between 1 and 1,000,000. Wie die Ausgabe des Beispiels zeigt, wird der Task, der durch Aufrufen der RunSynchronously-Methode ausgeführt wird, im Anwendungs Thread ausgeführt, während dies bei der asynchronen Aufgabe nicht der gibt.As the output from the example shows, the task executed by calling the RunSynchronously method runs on the application thread, while the asynchronous task does not.

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

Normalerweise werden Aufgaben asynchron in einem Thread Pool Thread ausgeführt, und der aufrufenden Thread wird nicht blockiert.Ordinarily, tasks are executed asynchronously on a thread pool thread and do not block the calling thread. Tasks, die durch den Aufruf der RunSynchronously()-Methode ausgeführt werden, sind der aktuellen TaskScheduler zugeordnet und werden auf dem aufrufenden Thread ausgeführt.Tasks executed by calling the RunSynchronously() method are associated with the current TaskScheduler and are run on the calling thread. Wenn das Ziel Planer das Ausführen dieser Aufgabe für den aufrufenden Thread nicht unterstützt, wird die Ausführung der Aufgabe im Scheduler geplant, und der aufrufende Thread wird blockiert, bis die Ausführung der Aufgabe abgeschlossen ist.If the target scheduler does not support running this task on the calling thread, the task will be scheduled for execution on the scheduler, and the calling thread will block until the task has completed execution. Obwohl die Aufgabe synchron ausgeführt wird, sollte der aufrufende Thread weiterhin Wait aufrufen, um alle Ausnahmen zu behandeln, die vom Task ausgelöst werden könnten.Even though the task runs synchronously, the calling thread should still call Wait to handle any exceptions that the task might throw. Weitere Informationen zur Ausnahmebehandlung finden Sie unter Ausnahmebehandlung.For more information on exception handling, see Exception Handling.

Tasks, die durch Aufrufen der RunSynchronously-Methode ausgeführt werden, werden durch Aufrufen eines Task-oder Task<TResult>-Klassenkonstruktors instanziiert.Tasks executed by calling the RunSynchronously method are instantiated by calling a Task or Task<TResult> class constructor. Der Task, der synchron ausgeführt werden soll, muss sich im Created-Zustand befinden.The task to be run synchronously must be in the Created state. Eine Aufgabe kann gestartet und nur einmal ausgeführt werden.A task may be started and run only once. Alle Versuche, eine Aufgabe ein zweites Mal zu planen, führen zu einer Ausnahme.Any attempts to schedule a task a second time results in an exception.

Siehe auch

RunSynchronously(TaskScheduler) RunSynchronously(TaskScheduler) RunSynchronously(TaskScheduler) RunSynchronously(TaskScheduler)

Führt die Task synchron mit dem bereitgestellten TaskScheduler aus.Runs the Task synchronously on the TaskScheduler provided.

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 TaskScheduler TaskScheduler TaskScheduler

Der Taskplaner, mit dem diese Aufgabe inline ausgeführt werden soll.The scheduler on which to attempt to run this task inline.

Ausnahmen

Die Task-Instanz wurde verworfen.The Task instance has been disposed.

Das scheduler-Argument lautet null.The scheduler argument is null.

Die Task liegt nicht in einem gültigen Zustand vor, um gestartet werden zu können.The Task is not in a valid state to be started. 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.It may have already been started, executed, or canceled, or it may have been created in a manner that doesn't support direct scheduling.

Hinweise

Tasks, die durch Aufrufen der RunSynchronously-Methode ausgeführt werden, werden durch Aufrufen eines Task-oder Task<TResult>-Klassenkonstruktors instanziiert.Tasks executed by calling the RunSynchronously method are instantiated by calling a Task or Task<TResult> class constructor. Der Task, der synchron ausgeführt werden soll, muss sich im Created-Zustand befinden.The task to be run synchronously must be in the Created state. Eine Aufgabe kann gestartet und nur einmal ausgeführt werden.A task may be started and run only once. Alle Versuche, eine Aufgabe ein zweites Mal zu planen, führen zu einer Ausnahme.Any attempts to schedule a task a second time results in an exception.

Wenn das Ziel Planer das Ausführen dieser Aufgabe für den aktuellen Thread nicht unterstützt, wird die Ausführung der Aufgabe im Scheduler geplant, und der aktuelle Thread wird blockiert, bis die Ausführung der Aufgabe abgeschlossen ist.If the target scheduler does not support running this task on the current thread, the task will be scheduled for execution on the scheduler, and the current thread will block until the task has completed execution. Aus diesem Grund muss der aufrufende Thread keine Methode wie Wait aufrufen, um sicherzustellen, dass die Ausführung der Aufgabe abgeschlossen ist.Because of this, the calling thread does not need to call a method such as Wait to ensure that the task has completed execution. Weitere Informationen zur Ausnahmebehandlung für Task Vorgänge finden Sie unter Ausnahmebehandlung.For more information on exception handling for task operations, see Exception Handling.

Siehe auch

Gilt für: