Task.RunSynchronously Methode

  • Referenz

Definition

Namespace:
System.Threading.Tasks
Assembly:
System.Threading.Tasks.dll
Assembly:
System.Runtime.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

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

Überlädt

RunSynchronously(TaskScheduler)

Führt die Task synchron mit dem bereitgestellten TaskScheduler aus.
RunSynchronously()

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

RunSynchronously(TaskScheduler)

Source:
Task.cs
Source:
Task.cs
Source:
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 -> unit
Public Sub RunSynchronously (scheduler As TaskScheduler)

Parameter

scheduler
TaskScheduler

Der Taskplaner, mit dem diese Aufgabe inline ausgeführt werden soll.

Ausnahmen

ObjectDisposedException

Die Task-Instanz wurde verworfen.

ArgumentNullException

Das scheduler-Argument lautet null.

InvalidOperationException

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.

Weitere Informationen

Gilt für:

RunSynchronously()

Source:
Task.cs
Source:
Task.cs
Source:
Task.cs

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

ObjectDisposedException

Die Task-Instanz wurde verworfen.

InvalidOperationException

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: