Task.RunSynchronously Task.RunSynchronously Task.RunSynchronously Task.RunSynchronously Method

Definizione

Esegue Task in modo sincrono nell'oggetto TaskScheduler corrente.Runs the Task synchronously on the current TaskScheduler.

Overload

RunSynchronously() RunSynchronously() RunSynchronously() RunSynchronously()

Esegue Task in modo sincrono nell'oggetto TaskScheduler corrente.Runs the Task synchronously on the current TaskScheduler.

RunSynchronously(TaskScheduler) RunSynchronously(TaskScheduler) RunSynchronously(TaskScheduler) RunSynchronously(TaskScheduler)

Esegue Task in modo sincrono nell'oggetto TaskScheduler fornito.Runs the Task synchronously on the TaskScheduler provided.

RunSynchronously() RunSynchronously() RunSynchronously() RunSynchronously()

Esegue Task in modo sincrono nell'oggetto TaskScheduler corrente.Runs the Task synchronously on the current TaskScheduler.

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

Eccezioni

L’istanza di Task è stata eliminata.The Task instance has been disposed.

Task non è in uno stato valido per essere avviato.The Task is not in a valid state to be started. Potrebbe essere già stato avviato, eseguito o annullato oppure potrebbe essere stato creato in un modo che non supporta la pianificazione diretta.It may have already been started, executed, or canceled, or it may have been created in a manner that doesn't support direct scheduling.

Esempi

L'esempio seguente confronta un'attività eseguita chiamando il RunSynchronously metodo con uno eseguita in modo asincrono.The following example compares a task executed by calling the RunSynchronously method with one executed asynchronously. In entrambi i casi, le attività eseguite le espressioni lambda identici che visualizzano l'ID attività e l'ID del thread in cui viene eseguita l'attività.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. L'attività calcola la somma dei numeri interi compresi tra 1 e 1.000.000.The task calculates the sum of the integers between 1 and 1,000,000. Come illustrato nell'output dell'esempio, l'attività eseguita chiamando il RunSynchronously metodo viene eseguito nel thread dell'applicazione, mentre l'attività asincrona non.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

Commenti

In genere, le attività vengono eseguite in modo asincrono in un pool di thread e non bloccano il thread chiamante.Ordinarily, tasks are executed asynchronously on a thread pool thread and do not block the calling thread. Attività eseguita chiamando il RunSynchronously() metodo associati corrente TaskScheduler e vengono eseguiti nel thread chiamante.Tasks executed by calling the RunSynchronously() method are associated with the current TaskScheduler and are run on the calling thread. Se l'utilità di pianificazione di destinazione non supporta l'esecuzione di questa attività nel thread chiamante, l'attività verrà pianificata per l'esecuzione nell'utilità di pianificazione e il thread chiama si bloccherà fino a quando l'attività ha completato l'esecuzione.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. Anche se l'attività viene eseguita in modo sincrono, il thread chiamante deve chiamare comunque Wait per gestire le eccezioni che potrebbe generare l'attività.Even though the task runs synchronously, the calling thread should still call Wait to handle any exceptions that the task might throw. Per altre informazioni sulla gestione delle eccezioni, vedere gestione delle eccezioni.For more information on exception handling, see Exception Handling.

Attività eseguita chiamando il RunSynchronously metodo istanze vengono create chiamando un Task o Task<TResult> costruttore della classe.Tasks executed by calling the RunSynchronously method are instantiated by calling a Task or Task<TResult> class constructor. Deve essere l'attività da eseguire in modo sincrono il Created dello stato.The task to be run synchronously must be in the Created state. Un'attività può essere avviata ed eseguire una sola volta.A task may be started and run only once. Qualsiasi tentativo di pianificare un'attività una seconda esecuzione, viene generato un'eccezione.Any attempts to schedule a task a second time results in an exception.

Vedi anche

RunSynchronously(TaskScheduler) RunSynchronously(TaskScheduler) RunSynchronously(TaskScheduler) RunSynchronously(TaskScheduler)

Esegue Task in modo sincrono nell'oggetto TaskScheduler fornito.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)

Parametri

scheduler
TaskScheduler TaskScheduler TaskScheduler TaskScheduler

Utilità di pianificazione in cui provare a eseguire questa attività inline.The scheduler on which to attempt to run this task inline.

Eccezioni

L’istanza di Task è stata eliminata.The Task instance has been disposed.

Il valore dell'argomento scheduler è null.The scheduler argument is null.

Task non è in uno stato valido per essere avviato.The Task is not in a valid state to be started. Potrebbe essere già stato avviato, eseguito o annullato oppure potrebbe essere stato creato in un modo che non supporta la pianificazione diretta.It may have already been started, executed, or canceled, or it may have been created in a manner that doesn't support direct scheduling.

Commenti

Attività eseguita chiamando il RunSynchronously metodo istanze vengono create chiamando un Task o Task<TResult> costruttore della classe.Tasks executed by calling the RunSynchronously method are instantiated by calling a Task or Task<TResult> class constructor. Deve essere l'attività da eseguire in modo sincrono il Created dello stato.The task to be run synchronously must be in the Created state. Un'attività può essere avviata ed eseguire una sola volta.A task may be started and run only once. Qualsiasi tentativo di pianificare un'attività una seconda esecuzione, viene generato un'eccezione.Any attempts to schedule a task a second time results in an exception.

Se l'utilità di pianificazione di destinazione non supporta l'esecuzione di questa attività nel thread corrente, l'attività verrà pianificata per l'esecuzione nell'utilità di pianificazione e il thread corrente si bloccherà fino a quando l'attività ha completato l'esecuzione.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. Per questo motivo, il thread chiamante non è necessario chiamare un metodo, ad esempio Wait per assicurarsi che l'attività ha completato l'esecuzione.Because of this, the calling thread does not need to call a method such as Wait to ensure that the task has completed execution. Per altre informazioni sulla gestione delle eccezioni per le operazioni di attività, vedere gestione delle eccezioni.For more information on exception handling for task operations, see Exception Handling.

Vedi anche

Si applica a