Task.RunSynchronously Methode

Definitie

Naamruimte:
System.Threading.Tasks
Assembly's:
mscorlib.dll, System.Threading.Tasks.dll
Assembly:
mscorlib.dll
Assembly:
System.Threading.Tasks.dll
Assembly:
netstandard.dll

Hiermee wordt de Task synchrone uitvoering uitgevoerd op de huidige TaskScheduler.

Overloads

Name Description
RunSynchronously()

Hiermee wordt de Task synchrone uitvoering uitgevoerd op de huidige TaskScheduler.
RunSynchronously(TaskScheduler)

Hiermee wordt de Task synchrone uitvoering uitgevoerd op de TaskScheduler opgegeven.

RunSynchronously()

Hiermee wordt de Task synchrone uitvoering uitgevoerd op de huidige TaskScheduler.

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

Uitzonderingen

ObjectDisposedException

Het Task exemplaar is verwijderd.

InvalidOperationException

De Task status is niet geldig om te worden gestart. Het is mogelijk al gestart, uitgevoerd of geannuleerd of is gemaakt op een manier die geen directe planning ondersteunt.

Voorbeelden

In het volgende voorbeeld wordt een taak vergeleken die wordt uitgevoerd door de RunSynchronously methode aan te roepen met één uitgevoerd asynchroon uitgevoerde taak. In beide gevallen voeren de taken identieke lambda-expressies uit die de taak-id en de id weergeven van de thread waarop de taak wordt uitgevoerd. De taak berekent de som van de gehele getallen tussen 1 en 1.000.000. Zoals de uitvoer uit het voorbeeld laat zien, wordt de taak uitgevoerd door de RunSynchronously methode aan te roepen op de toepassingsthread, terwijl de asynchrone taak dat niet doet.

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

Opmerkingen

Normaal gesproken worden taken asynchroon uitgevoerd op een threadgroep en worden de aanroepende thread niet geblokkeerd. Taken die worden uitgevoerd door de RunSynchronously() methode aan te roepen, zijn gekoppeld aan de huidige TaskScheduler en worden uitgevoerd op de aanroepende thread. Als de doelplanner geen ondersteuning biedt voor het uitvoeren van deze taak op de aanroepende thread, wordt de taak gepland voor uitvoering op de planner en wordt de aanroepende thread geblokkeerd totdat de taak is uitgevoerd. Hoewel de taak synchroon wordt uitgevoerd, moet de aanroepende thread nog steeds aanroepen Wait om eventuele uitzonderingen af te handelen die de taak kan genereren. Zie Uitzonderingsafhandeling voor meer informatie over het afhandelen van uitzonderingen.

Taken die worden uitgevoerd door het aanroepen van de RunSynchronously methode, worden geïnstantieerd door een Task of Task<TResult> klasseconstructor aan te roepen. De taak die synchroon moet worden uitgevoerd, moet de Created status hebben. Een taak kan slechts eenmaal worden gestart en uitgevoerd. Pogingen om een taak een tweede keer te plannen, resulteert in een uitzondering.

Zie ook

Van toepassing op

RunSynchronously(TaskScheduler)

Hiermee wordt de Task synchrone uitvoering uitgevoerd op de TaskScheduler opgegeven.

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)

Parameters

scheduler
TaskScheduler

De planner waarop moet worden geprobeerd deze taak inline uit te voeren.

Uitzonderingen

ObjectDisposedException

Het Task exemplaar is verwijderd.

ArgumentNullException

Het scheduler argument is null.

InvalidOperationException

De Task status is niet geldig om te worden gestart. Het is mogelijk al gestart, uitgevoerd of geannuleerd of is gemaakt op een manier die geen directe planning ondersteunt.

Opmerkingen

Taken die worden uitgevoerd door het aanroepen van de RunSynchronously methode, worden geïnstantieerd door een Task of Task<TResult> klasseconstructor aan te roepen. De taak die synchroon moet worden uitgevoerd, moet de Created status hebben. Een taak kan slechts eenmaal worden gestart en uitgevoerd. Pogingen om een taak een tweede keer te plannen, resulteert in een uitzondering.

Als de doelplanner geen ondersteuning biedt voor het uitvoeren van deze taak op de huidige thread, wordt de taak gepland voor uitvoering op de planner en wordt de huidige thread geblokkeerd totdat de taak is uitgevoerd. Daarom hoeft de aanroepende thread geen methode aan te roepen, bijvoorbeeld Wait om ervoor te zorgen dat de taak de uitvoering heeft voltooid. Zie Uitzonderingsafhandeling voor meer informatie over de afhandeling van uitzonderingen voor taakbewerkingen.

Zie ook

Van toepassing op