Task.RunSynchronously Método

Definição

Espaço de Nomes:
System.Threading.Tasks
Assemblagens:
mscorlib.dll, System.Threading.Tasks.dll
Assemblagens:
netstandard.dll, System.Runtime.dll
Assemblagem:
System.Threading.Tasks.dll
Assemblagem:
System.Runtime.dll
Assemblagem:
mscorlib.dll
Assemblagem:
netstandard.dll

Executa sincronizadamente Task com a corrente TaskScheduler.

Sobrecargas

Name Description
RunSynchronously()

Executa sincronizadamente Task com a corrente TaskScheduler.
RunSynchronously(TaskScheduler)

Executa o Task sistema síncronicamente no TaskScheduler fornecido.

RunSynchronously()

Origem:
Task.cs
Origem:
Task.cs
Origem:
Task.cs
Origem:
Task.cs
Origem:
Task.cs

Executa sincronizadamente Task com a corrente TaskScheduler.

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

Exceções

ObjectDisposedException

O Task caso foi resolvido.

InvalidOperationException

Não Task está num estado válido para ser iniciado. Pode já ter sido iniciado, executado ou cancelado, ou pode ter sido criado de uma forma que não suporta agendamento direto.

Exemplos

O exemplo seguinte compara uma tarefa executada ao chamar o RunSynchronously método com outra executada de forma assíncrona. Em ambos os casos, as tarefas executam expressões lambda idênticas que mostram o ID da tarefa e o ID do thread onde a tarefa está a correr. A tarefa calcula a soma dos inteiros entre 1 e 1.000.000. Como mostra o resultado do exemplo, a tarefa executada ao chamar o RunSynchronously método é executada no thread da aplicação, 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

Observações

Normalmente, as tarefas são executadas de forma assíncrona numa thread pool e não bloqueiam a thread que chama. As tarefas executadas ao chamar o RunSynchronously() método são associadas ao atual TaskScheduler e executadas no thread que chama. Se o agendador de destino não suportar a execução desta tarefa no thread que chama, a tarefa será agendada para execução no scheduler, e o thread que chama será bloqueado até que a tarefa seja concluída. Mesmo que a tarefa corra de forma síncrona, o thread que chama deve continuar a chamar Wait para lidar com quaisquer exceções que a tarefa possa lançar. Para mais informações sobre o tratamento de exceções, veja Tratamento de Exceções.

As tarefas executadas ao chamar o RunSynchronously método são instanciadas ao chamar 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 numa exceção.

Ver também

Aplica-se a

RunSynchronously(TaskScheduler)

Origem:
Task.cs
Origem:
Task.cs
Origem:
Task.cs
Origem:
Task.cs
Origem:
Task.cs

Executa o Task sistema síncronicamente 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 -> unit
Public Sub RunSynchronously (scheduler As TaskScheduler)

Parâmetros

scheduler
TaskScheduler

O agendador onde tentar executar esta tarefa em linha.

Exceções

ObjectDisposedException

O Task caso foi resolvido.

ArgumentNullException

O scheduler argumento é null.

InvalidOperationException

Não Task está num estado válido para ser iniciado. Pode já ter sido iniciado, executado ou cancelado, ou pode ter sido criado de uma forma que não suporta agendamento direto.

Observações

As tarefas executadas ao chamar o RunSynchronously método são instanciadas ao chamar 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 numa exceção.

Se o agendador de destino não suportar a execução desta tarefa no thread atual, a tarefa será agendada para execução no scheduler, e o thread atual bloqueará até que a tarefa seja concluída. Por causa disso, o thread que chama não precisa de chamar um método para Wait garantir que a tarefa foi executada. Para mais informações sobre o tratamento de exceções para operações de tarefas, veja Gestão de Exceções.

Ver também

Aplica-se a