Task.RunSynchronously Método
Definição
Importante
Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.
Executa o Task de forma síncrona no TaskScheduler atual.
Sobrecargas
| RunSynchronously(TaskScheduler) |
Executa o Task de forma síncrona no TaskScheduler fornecido. |
| RunSynchronously() |
Executa o Task de forma síncrona no TaskScheduler atual. |
RunSynchronously(TaskScheduler)
- Source:
- Task.cs
- Source:
- Task.cs
- Source:
- Task.cs
Executa o Task de forma síncrona no TaskScheduler fornecido.
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
O agendador no qual haverá a tentativa de executar essa tarefa embutida.
Exceções
A instância Task foi descartada.
O argumento scheduler é null.
O Task não está em um estado válido para ser iniciado. Ele pode já ter sido iniciado, executado ou cancelado ou pode ter sido criado de forma a não dar suporte ao agendamento direto.
Comentários
As tarefas executadas chamando o RunSynchronously método são instanciadas chamando um Task construtor de classe ou Task<TResult> . A tarefa a ser executada de forma síncrona deve estar no Created estado . Uma tarefa pode ser iniciada e executada apenas uma vez. Qualquer tentativa de agendar uma tarefa uma segunda vez resulta em uma exceção.
Se o agendador de destino não der suporte à execução dessa tarefa no thread atual, a tarefa será agendada para execução no agendador e o thread atual será bloqueado até que a tarefa tenha concluído a execução. Por isso, o thread de chamada não precisa chamar um método como Wait para garantir que a tarefa tenha concluído a execução. Para obter mais informações sobre o tratamento de exceções para operações de tarefa, consulte Tratamento de exceções.
Confira também
Aplica-se a
RunSynchronously()
- Source:
- Task.cs
- Source:
- Task.cs
- Source:
- Task.cs
Executa o Task de forma síncrona no TaskScheduler atual.
public:
void RunSynchronously();public void RunSynchronously ();member this.RunSynchronously : unit -> unitPublic Sub RunSynchronously ()Exceções
A instância Task foi descartada.
O Task não está em um estado válido para ser iniciado. Ele pode já ter sido iniciado, executado ou cancelado ou pode ter sido criado de forma a não dar suporte ao agendamento direto.
Exemplos
O exemplo a seguir compara uma tarefa executada chamando o RunSynchronously método com um executado de forma assíncrona. Em ambos os casos, as tarefas executam expressões lambda idênticas que exibem a ID da tarefa e a ID do thread no qual a tarefa está em execução. A tarefa calcula a soma dos inteiros entre 1 e 1.000.000. Como mostra a saída do exemplo, a tarefa executada chamando o RunSynchronously método é executada no thread do aplicativo, enquanto a tarefa assíncrona não.
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
Comentários
Normalmente, as tarefas são executadas de forma assíncrona em um thread do pool de threads e não bloqueiam o thread de chamada. As tarefas executadas chamando o RunSynchronously() método são associadas ao atual TaskScheduler e são executadas no thread de chamada. Se o agendador de destino não der suporte à execução dessa tarefa no thread de chamada, a tarefa será agendada para execução no agendador e o thread de chamada será bloqueado até que a tarefa tenha concluído a execução. Embora a tarefa seja executada de forma síncrona, o thread de chamada ainda deve chamar Wait para lidar com quaisquer exceções que a tarefa possa gerar. Para obter mais informações sobre o tratamento de exceções, consulte Tratamento de exceções.
As tarefas executadas chamando o RunSynchronously método são instanciadas chamando um Task construtor de classe ou Task<TResult> . A tarefa a ser executada de forma síncrona deve estar no Created estado . Uma tarefa pode ser iniciada e executada apenas uma vez. Qualquer tentativa de agendar uma tarefa uma segunda vez resulta em uma exceção.
Confira também
Aplica-se a
Comentários
Em breve: Ao longo de 2024, eliminaremos os problemas do GitHub como o mecanismo de comentários para conteúdo e o substituiremos por um novo sistema de comentários. Para obter mais informações, consulte https://aka.ms/ContentUserFeedback.
Enviar e exibir comentários de