Task.RunSynchronously Método

Definición

Espacio de nombres:
System.Threading.Tasks
Ensamblados:
mscorlib.dll, System.Threading.Tasks.dll
Ensamblado:
mscorlib.dll
Ensamblado:
System.Threading.Tasks.dll
Ensamblado:
netstandard.dll

Ejecuta de Task forma sincrónica en el objeto actual TaskScheduler.

Sobrecargas

Nombre Description
RunSynchronously()

Ejecuta de Task forma sincrónica en el objeto actual TaskScheduler.
RunSynchronously(TaskScheduler)

Ejecuta la Task sincrónicamente en el TaskScheduler proporcionado.

RunSynchronously()

Ejecuta de Task forma sincrónica en el objeto actual TaskScheduler.

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

Excepciones

ObjectDisposedException

La Task instancia se ha eliminado.

InvalidOperationException

no Task está en un estado válido que se va a iniciar. Es posible que ya se haya iniciado, ejecutado o cancelado, o que se haya creado de una manera que no admita la programación directa.

Ejemplos

En el ejemplo siguiente se compara una tarea ejecutada mediante una llamada al RunSynchronously método con una ejecutada de forma asincrónica. 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 ejecuta la tarea. La tarea calcula la suma de los enteros entre 1 y 1000 000. Como se muestra en la salida del ejemplo, la tarea ejecutada llamando al RunSynchronously método se ejecuta en el subproceso de la aplicación, mientras que la tarea asincrónica no.

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

Comentarios

Normalmente, las tareas se ejecutan de forma asincrónica en un subproceso de grupo de subprocesos y no bloquean el subproceso que realiza la llamada. Las tareas ejecutadas mediante una llamada al RunSynchronously() método están asociadas al actual TaskScheduler y se ejecutan en el subproceso que realiza la llamada. 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 la tarea haya completado la ejecución. Aunque la tarea se ejecuta de forma sincrónica, el subproceso que realiza la llamada debe seguir llamando Wait para controlar las excepciones que podría producir la tarea. Para obtener más información sobre el control de excepciones, consulte Control de excepciones.

Las tareas ejecutadas mediante una llamada al RunSynchronously método se crean instancias mediante una llamada a un Task constructor de clase o Task<TResult> . La tarea que se va a ejecutar de forma sincrónica debe estar en estado Created . Una tarea puede iniciarse y ejecutarse solo una vez. Los intentos de programar una tarea una segunda vez producen una excepción.

Consulte también

Se aplica a

RunSynchronously(TaskScheduler)

Ejecuta la Task sincrónicamente en el TaskScheduler proporcionado.

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 intenta ejecutar esta tarea insertada.

Excepciones

ObjectDisposedException

La Task instancia se ha eliminado.

ArgumentNullException

El scheduler argumento es null.

InvalidOperationException

no Task está en un estado válido que se va a iniciar. Es posible que ya se haya iniciado, ejecutado o cancelado, o que se haya creado de una manera que no admita la programación directa.

Comentarios

Las tareas ejecutadas mediante una llamada al RunSynchronously método se crean instancias mediante una llamada a un Task constructor de clase o Task<TResult> . La tarea que se va a ejecutar de forma sincrónica debe estar en estado Created . Una tarea puede iniciarse y ejecutarse solo una vez. Los intentos de programar una tarea una segunda vez producen una excepción.

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 la tarea haya completado la ejecución. 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 completado la ejecución. Para obtener más información sobre el control de excepciones para las operaciones de tareas, vea Control de excepciones.

Consulte también

Se aplica a