Task.RunSynchronously Metodo

Definizione

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

Overload

RunSynchronously()

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

RunSynchronously(TaskScheduler)

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

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

Nell'esempio seguente viene confrontata un'attività eseguita chiamando il metodo RunSynchronously con una 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à eseguono espressioni lambda identiche che visualizzano l'ID dell'attività e l'ID del thread in cui è in esecuzione 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 milione.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 metodo RunSynchronously viene eseguita sul thread dell'applicazione, mentre l'attività asincrona non lo fa.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 thread del 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. Le attività eseguite chiamando il metodo RunSynchronously() sono associate al TaskScheduler corrente e vengono eseguite sul 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à sul thread chiamante, l'attività verrà pianificata per l'esecuzione nell'utilità di pianificazione e il thread chiamante verrà bloccato fino al completamento dell'esecuzione dell'attività.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 comunque chiamare Wait per gestire le eccezioni che potrebbero essere generate dall'attività.Even though the task runs synchronously, the calling thread should still call Wait to handle any exceptions that the task might throw. Per ulteriori informazioni sulla gestione delle eccezioni, vedere gestione delle eccezioni.For more information on exception handling, see Exception Handling.

Viene creata un'istanza delle attività eseguite chiamando il metodo RunSynchronously chiamando un costruttore di classe Task o Task<TResult>.Tasks executed by calling the RunSynchronously method are instantiated by calling a Task or Task<TResult> class constructor. L'attività da eseguire in modo sincrono deve essere nello stato Created.The task to be run synchronously must be in the Created state. Un'attività può essere avviata ed eseguita una sola volta.A task may be started and run only once. Eventuali tentativi di pianificare un'attività una seconda volta generano un'eccezione.Any attempts to schedule a task a second time results in an exception.

Vedi anche

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

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

Viene creata un'istanza delle attività eseguite chiamando il metodo RunSynchronously chiamando un costruttore di classe Task o Task<TResult>.Tasks executed by calling the RunSynchronously method are instantiated by calling a Task or Task<TResult> class constructor. L'attività da eseguire in modo sincrono deve essere nello stato Created.The task to be run synchronously must be in the Created state. Un'attività può essere avviata ed eseguita una sola volta.A task may be started and run only once. Eventuali tentativi di pianificare un'attività una seconda volta generano 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à sul thread corrente, l'attività verrà pianificata per l'esecuzione nell'utilità di pianificazione e il thread corrente si bloccherà fino al completamento dell'esecuzione dell'attività.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, non è necessario che il thread chiamante chiami un metodo come Wait per assicurarsi che l'attività abbia 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 ulteriori 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