Task.RunSynchronously Método

  • Referencia

Definición

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

Ejecuta sincrónicamente el objeto Task en el objeto TaskScheduler actual.

Sobrecargas

RunSynchronously(TaskScheduler)

Ejecuta sincrónicamente el objeto Task en el objeto TaskScheduler proporcionado.
RunSynchronously()

Ejecuta sincrónicamente el objeto Task en el objeto TaskScheduler actual.

RunSynchronously(TaskScheduler)

Source:
Task.cs
Source:
Task.cs
Source:
Task.cs

Ejecuta sincrónicamente el objeto Task en el objeto 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 va a intentar ejecutar esta tarea insertada.

Excepciones

ObjectDisposedException

Se eliminó la instancia de Task.

ArgumentNullException

El argumento scheduler es null.

InvalidOperationException

Task no se encuentra en un estado válido para iniciarse. 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.

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 el Created estado . Una tarea se puede iniciar y ejecutar solo una vez. Cualquier intento de programar una tarea una segunda vez produce 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, consulte Control de excepciones.

Consulte también

Se aplica a

RunSynchronously()

Source:
Task.cs
Source:
Task.cs
Source:
Task.cs

Ejecuta sincrónicamente el objeto Task en el objeto TaskScheduler actual.

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

Excepciones

ObjectDisposedException

Se eliminó la instancia de Task.

InvalidOperationException

Task no se encuentra en un estado válido para iniciarse. 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.

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 lo hace.

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 del 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 con el 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, vea 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 el Created estado . Una tarea se puede iniciar y ejecutar solo una vez. Cualquier intento de programar una tarea una segunda vez produce una excepción.

Consulte también

Se aplica a