Task.RunSynchronously Metoda

Definice

Obor názvů:

System.Threading.Tasks

Sestavení:

netstandard.dll, System.Runtime.dll

Task Spouští synchronně na aktuálním TaskScheduler.

Přetížení

Name	Description
RunSynchronously()	Task Spouští synchronně na aktuálním TaskScheduler.
RunSynchronously(TaskScheduler)	Task Spustí synchronně na zadaném TaskScheduler počítači.

RunSynchronously()

Zdroj:

Task.cs

Task Spouští synchronně na aktuálním TaskScheduler.

public:
 void RunSynchronously();

public void RunSynchronously();

member this.RunSynchronously : unit -> unit

Public Sub RunSynchronously ()

Výjimky

ObjectDisposedException

Instance Task byla odstraněna.

InvalidOperationException

Není Task v platném stavu, který se má spustit. Možná už byl spuštěný, spuštěný nebo zrušený nebo byl vytvořen způsobem, který nepodporuje přímé plánování.

Příklady

Následující příklad porovnává úlohu spuštěnou voláním RunSynchronously metody s jedním spuštěným asynchronně. V obou případech úlohy provádějí identické výrazy lambda, které zobrazují ID úlohy a ID vlákna, na kterém je úloha spuštěna. Úkol vypočítá součet celých čísel mezi 1 a 1 000 000. Jak ukazuje výstup z příkladu, úloha spuštěná voláním RunSynchronously metody běží ve vlákně aplikace, zatímco asynchronní úloha ne.

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

Poznámky

Obvykle se úlohy spouští asynchronně ve vlákně fondu vláken a neblokují volající vlákno. Úlohy spouštěné voláním RunSynchronously() metody jsou přidruženy k aktuálnímu TaskScheduler a jsou spuštěny ve volajícím vlákně. Pokud cílový plánovač nepodporuje spuštění této úlohy ve volajícím vlákně, bude úloha naplánovaná na spuštění plánovače a volající vlákno bude blokováno, dokud úloha nedokončí provádění. I když úloha běží synchronně, volající vlákno by stále mělo volat Wait za účelem zpracování všech výjimek, které může úloha vyvolat. Další informace o zpracovánívýjimekch

Úlohy spouštěné voláním RunSynchronously metody jsou vytvořena voláním konstruktoru Task třídy Task<TResult> . Úloha, která se má spustit synchronně, musí být ve Created stavu. Úkol může být spuštěn a spuštěn pouze jednou. Při každém pokusu o naplánování úkolu dojde k druhé výjimce.

Viz také

• Zpracování výjimek (paralelní knihovna úloh)

RunSynchronously(TaskScheduler)

Zdroj:

Task.cs

Task Spustí synchronně na zadaném TaskScheduler počítači.

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)

Parametry

scheduler

TaskScheduler

Plánovač, na kterém se chcete pokusit spustit tuto úlohu v textu.

Výjimky

ObjectDisposedException

Instance Task byla odstraněna.

ArgumentNullException

Argument scheduler je null.

InvalidOperationException

Není Task v platném stavu, který se má spustit. Možná už byl spuštěný, spuštěný nebo zrušený nebo byl vytvořen způsobem, který nepodporuje přímé plánování.

Poznámky

Úlohy spouštěné voláním RunSynchronously metody jsou vytvořena voláním konstruktoru Task třídy Task<TResult> . Úloha, která se má spustit synchronně, musí být ve Created stavu. Úkol může být spuštěn a spuštěn pouze jednou. Při každém pokusu o naplánování úkolu dojde k druhé výjimce.

Pokud cílový plánovač nepodporuje spuštění této úlohy v aktuálním vlákně, bude úloha naplánovaná pro spuštění plánovače a aktuální vlákno bude blokováno, dokud úloha nedokončí provádění. Z tohoto důvodu volající vlákno nemusí volat metodu, jako Wait je například zajistit, aby úloha dokončila provádění. Další informace o zpracování výjimek pro operace úloh naleznete v tématu Zpracování výjimek.

Viz také

• TaskScheduler
• Zpracování výjimek (paralelní knihovna úloh)