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, die durch einen Aufruf von der RunSynchronously Methode mit einem der asynchron ausgeführt.The following example compares a task executed by calling the RunSynchronously method with one executed asynchronously. Führen Sie identische Lambda-Ausdrücke, die die Task-ID und die ID des Threads anzeigen in beiden Fällen die Aufgaben auf dem der Task ausgeführt wird.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.000.000.The task calculates the sum of the integers between 1 and 1,000,000. Wie die Ausgabe des Beispiels zeigt, wird die Aufgabe ausgeführt, durch den Aufruf der RunSynchronously Methode auf dem Thread der Anwendung ausgeführt wird, während die asynchrone Aufgabe nicht der Fall ist.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 die Aufgaben asynchron auf einem Threadpoolthread ausgeführt werden und der aufrufenden Thread nicht blockieren.Ordinarily, tasks are executed asynchronously on a thread pool thread and do not block the calling thread. Aufgaben, die durch einen Aufruf von der RunSynchronously() Methode sind verknüpft, mit dem aktuellen TaskScheduler und für den aufrufenden Thread ausgeführt werden.Tasks executed by calling the RunSynchronously() method are associated with the current TaskScheduler and are run on the calling thread. Wenn der Zielplaner das Ausführen dieser Aufgabe im aufrufenden Thread nicht unterstützt, die Aufgabe zur Ausführung auf den Planer geplant werden, und der aufrufende Thread blockiert, bis der Task die Ausführung 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. Auch wenn der Vorgang synchron ausgeführt wird, sollten immer noch der aufrufende Thread Aufrufen Wait , alle Ausnahmen zu behandeln, die die Aufgabe möglicherweise auslösen.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 Exception Handling.For more information on exception handling, see Exception Handling.

Aufgaben, die durch einen Aufruf von der RunSynchronously Methode werden instanziiert, durch den Aufruf einer Task oder Task<TResult> Klassenkonstruktor.Tasks executed by calling the RunSynchronously method are instantiated by calling a Task or Task<TResult> class constructor. Die Task synchron ausgeführt werden muss, der Created Zustand.The task to be run synchronously must be in the Created state. Eine Aufgabe kann gestartet und werden nur einmal ausgeführt werden.A task may be started and run only once. Alle Versuche, einer Aufgabe ein zweites Mal führt zu einer Ausnahme zu planen.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

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

Wenn der Zielplaner Ausführen dieser Aufgabe für den aktuellen Thread nicht unterstützt wird, der Task zur Ausführung auf den Planer geplant werden und der aktuelle Thread blockiert, bis der Task die Ausführung 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 der aufrufende Thread muss nicht auf eine Methode aufrufen, z. B. Wait um sicherzustellen, dass der Task die Ausführung 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 Vorgänge, finden Sie unter Exception Handling.For more information on exception handling for task operations, see Exception Handling.

Siehe auch

Gilt für: