Task.RunSynchronously Método
Definición
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
Ejecuta sincrónicamente el objeto Task en el objeto TaskScheduler actual.
Sobrecargas
| RunSynchronously() |
Ejecuta sincrónicamente el objeto Task en el objeto TaskScheduler actual. |
| RunSynchronously(TaskScheduler) |
Ejecuta sincrónicamente el objeto Task en el objeto TaskScheduler proporcionado. |
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 -> unitPublic Sub RunSynchronously ()Excepciones
Se eliminó la instancia de Task.
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
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 -> unitPublic Sub RunSynchronously (scheduler As TaskScheduler)Parámetros
- scheduler
- TaskScheduler
Programador en el que se va a intentar ejecutar esta tarea insertada.
Excepciones
Se eliminó la instancia de Task.
El argumento scheduler es null.
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.
