Task.RunSynchronously Metoda

Definice

Spustí Task synchronně na aktuální TaskScheduler.Runs the Task synchronously on the current TaskScheduler.

Přetížení

RunSynchronously()

Spustí Task synchronně na aktuální TaskScheduler.Runs the Task synchronously on the current TaskScheduler.

RunSynchronously(TaskScheduler)

Spustí Task synchronně na poskytnuté TaskScheduler.Runs the Task synchronously on the TaskScheduler provided.

RunSynchronously()

Spustí Task synchronně na aktuální TaskScheduler.Runs the Task synchronously on the current TaskScheduler.

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

Výjimky

Instance Task byla vyřazena.The Task instance has been disposed.

Task není v platném stavu, aby bylo možné spustit.The Task is not in a valid state to be started. Je možné, že už je spuštěná, spuštěná nebo zrušená, nebo se vytvořil způsobem, který nepodporuje přímé plánování.It may have already been started, executed, or canceled, or it may have been created in a manner that doesn't support direct scheduling.

Příklady

Následující příklad porovnává úlohu spuštěnou voláním metody RunSynchronously s jedním provedeným asynchronně.The following example compares a task executed by calling the RunSynchronously method with one executed asynchronously. V obou případech úlohy spouštějí identické lambda výrazy, které zobrazují ID úlohy a ID vlákna, na kterém je úloha spuštěná.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. Úkol vypočítá součet celých čísel v rozmezí od 1 do 1 000 000.The task calculates the sum of the integers between 1 and 1,000,000. Jak ukazuje výstup z příkladu, úloha spuštěná voláním metody RunSynchronously se spouští ve vlákně aplikace, zatímco asynchronní úloha ne.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

Poznámky

Úlohy jsou obvykle spouštěny asynchronně ve vlákně fondu vláken a neblokují volající vlákno.Ordinarily, tasks are executed asynchronously on a thread pool thread and do not block the calling thread. Úkoly spouštěné voláním metody RunSynchronously() jsou přidruženy k aktuálnímu TaskScheduler a jsou spuštěny v volajícím vlákně.Tasks executed by calling the RunSynchronously() method are associated with the current TaskScheduler and are run on the calling thread. Pokud cílový Plánovač nepodporuje spuštění této úlohy ve volajícím vlákně, úloha bude naplánována na spuštění v Plánovači a volající vlákno se zablokuje, dokud se úloha nedokončí provedení.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. I když je úloha spuštěná synchronně, volající vlákno by dál mělo volat Wait, aby zpracovávala všechny výjimky, které může úkol vyvolat.Even though the task runs synchronously, the calling thread should still call Wait to handle any exceptions that the task might throw. Další informace o zpracování výjimek naleznete v tématu zpracování výjimek.For more information on exception handling, see Exception Handling.

Úkoly spouštěné voláním metody RunSynchronously jsou vytvořeny pomocí volání konstruktoru třídy Task nebo Task<TResult>.Tasks executed by calling the RunSynchronously method are instantiated by calling a Task or Task<TResult> class constructor. Úloha, která se má spustit synchronně, musí být ve stavu Created.The task to be run synchronously must be in the Created state. Úlohu lze spustit a spustit pouze jednou.A task may be started and run only once. Jakékoli pokusy o naplánování úlohy podruhé budou mít za následek výjimku.Any attempts to schedule a task a second time results in an exception.

Viz také

RunSynchronously(TaskScheduler)

Spustí Task synchronně na poskytnuté TaskScheduler.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)

Parametry

scheduler
TaskScheduler

Plánovač, ve kterém se má tento úkol spustit jako vloženýThe scheduler on which to attempt to run this task inline.

Výjimky

Instance Task byla vyřazena.The Task instance has been disposed.

Argument scheduler je null.The scheduler argument is null.

Task není v platném stavu, aby bylo možné spustit.The Task is not in a valid state to be started. Je možné, že už je spuštěná, spuštěná nebo zrušená, nebo se vytvořil způsobem, který nepodporuje přímé plánování.It may have already been started, executed, or canceled, or it may have been created in a manner that doesn't support direct scheduling.

Poznámky

Úkoly spouštěné voláním metody RunSynchronously jsou vytvořeny pomocí volání konstruktoru třídy Task nebo Task<TResult>.Tasks executed by calling the RunSynchronously method are instantiated by calling a Task or Task<TResult> class constructor. Úloha, která se má spustit synchronně, musí být ve stavu Created.The task to be run synchronously must be in the Created state. Úlohu lze spustit a spustit pouze jednou.A task may be started and run only once. Jakékoli pokusy o naplánování úlohy podruhé budou mít za následek výjimku.Any attempts to schedule a task a second time results in an exception.

Pokud cílový Plánovač nepodporuje spuštění této úlohy v aktuálním vlákně, úloha bude naplánována na spuštění v Plánovači a aktuální vlákno bude zablokováno, dokud se úloha nedokončí provedení.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. Z tohoto důvodu volající vlákno nemusí volat metodu, jako je například Wait, aby bylo zajištěno, že úloha dokončila provádění.Because of this, the calling thread does not need to call a method such as Wait to ensure that the task has completed execution. Další informace o zpracování výjimek pro operace úloh naleznete v tématu zpracování výjimek.For more information on exception handling for task operations, see Exception Handling.

Viz také

Platí pro