Task.RunSynchronously Método

Definición

Ejecuta sincrónicamente el objeto Task en el objeto TaskScheduler actual.Runs the Task synchronously on the current TaskScheduler.

Sobrecargas

RunSynchronously()

Ejecuta sincrónicamente el objeto Task en el objeto TaskScheduler actual.Runs the Task synchronously on the current TaskScheduler.

RunSynchronously(TaskScheduler)

Ejecuta sincrónicamente el objeto Task en el objeto TaskScheduler proporcionado.Runs the Task synchronously on the TaskScheduler provided.

RunSynchronously()

Ejecuta sincrónicamente el objeto Task en el objeto TaskScheduler actual.Runs the Task synchronously on the current TaskScheduler.

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

Excepciones

Se eliminó la instancia de Task.The Task instance has been disposed.

Task no se encuentra en un estado válido para iniciarse.The Task is not in a valid state to be started. Puede que ya se iniciase, se ejecutase o se cancelase, o puede que se crease de una manera que no admite la programación directa.It may have already been started, executed, or canceled, or it may have been created in a manner that doesn't support direct scheduling.

Ejemplos

En el ejemplo siguiente se compara una tarea ejecutada llamando al método RunSynchronously con una ejecutada de forma asincrónica.The following example compares a task executed by calling the RunSynchronously method with one executed asynchronously. En ambos casos, las tareas ejecutan expresiones lambda idénticas que muestran el identificador de tarea y el identificador del subproceso en el que se está ejecutando la tarea.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. La tarea calcula la suma de los enteros comprendidos entre 1 y 1 millón.The task calculates the sum of the integers between 1 and 1,000,000. Como muestra la salida del ejemplo, la tarea ejecutada llamando al método RunSynchronously se ejecuta en el subproceso de la aplicación, mientras que la tarea asincrónica no lo hace.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

Comentarios

Normalmente, las tareas se ejecutan de forma asincrónica en un subproceso del grupo de subprocesos y no bloquean el subproceso que realiza la llamada.Ordinarily, tasks are executed asynchronously on a thread pool thread and do not block the calling thread. Las tareas ejecutadas mediante una llamada al método RunSynchronously() están asociadas a la TaskScheduler actual y se ejecutan en el subproceso que realiza la llamada.Tasks executed by calling the RunSynchronously() method are associated with the current TaskScheduler and are run on the calling thread. Si el programador de destino no admite la ejecución de esta tarea en el subproceso que realiza la llamada, la tarea se programará para su ejecución en el programador y el subproceso que realiza la llamada se bloqueará hasta que se complete la ejecución de la tarea.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. Aunque la tarea se ejecuta sincrónicamente, el subproceso que realiza la llamada debe seguir llamando a Wait para controlar las excepciones que puede iniciar la tarea.Even though the task runs synchronously, the calling thread should still call Wait to handle any exceptions that the task might throw. Para obtener más información sobre el control de excepciones, vea control de excepciones.For more information on exception handling, see Exception Handling.

Las tareas ejecutadas al llamar al método RunSynchronously se crean mediante una llamada a un constructor de clase Task o Task<TResult>.Tasks executed by calling the RunSynchronously method are instantiated by calling a Task or Task<TResult> class constructor. La tarea que se va a ejecutar de forma sincrónica debe estar en el estado Created.The task to be run synchronously must be in the Created state. Una tarea puede iniciarse y ejecutarse una sola vez.A task may be started and run only once. Cualquier intento de programar una tarea por segunda vez produce una excepción.Any attempts to schedule a task a second time results in an exception.

Consulte también:

RunSynchronously(TaskScheduler)

Ejecuta sincrónicamente el objeto Task en el objeto TaskScheduler proporcionado.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)

Parámetros

scheduler
TaskScheduler

Programador en el que se va a intentar ejecutar esta tarea insertada.The scheduler on which to attempt to run this task inline.

Excepciones

Se eliminó la instancia de Task.The Task instance has been disposed.

El argumento scheduler es null.The scheduler argument is null.

Task no se encuentra en un estado válido para iniciarse.The Task is not in a valid state to be started. Puede que ya se iniciase, se ejecutase o se cancelase, o puede que se crease de una manera que no admite la programación directa.It may have already been started, executed, or canceled, or it may have been created in a manner that doesn't support direct scheduling.

Comentarios

Las tareas ejecutadas al llamar al método RunSynchronously se crean mediante una llamada a un constructor de clase Task o Task<TResult>.Tasks executed by calling the RunSynchronously method are instantiated by calling a Task or Task<TResult> class constructor. La tarea que se va a ejecutar de forma sincrónica debe estar en el estado Created.The task to be run synchronously must be in the Created state. Una tarea puede iniciarse y ejecutarse una sola vez.A task may be started and run only once. Cualquier intento de programar una tarea por segunda vez produce una excepción.Any attempts to schedule a task a second time results in an exception.

Si el programador de destino no admite la ejecución de esta tarea en el subproceso actual, la tarea se programará para su ejecución en el programador y el subproceso actual se bloqueará hasta que se complete la ejecución de la tarea.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. Por este motivo, el subproceso que realiza la llamada no necesita llamar a un método como Wait para asegurarse de que la tarea ha finalizado la ejecució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. Para obtener más información sobre el control de excepciones para las operaciones de tareas, vea control de excepciones.For more information on exception handling for task operations, see Exception Handling.

Consulte también:

Se aplica a