Task.Wait Método

Definição

Namespace:

System.Threading.Tasks

Assembly:

System.Runtime.dll

Aguarda o Task concluir a execução.

Sobrecargas

Wait(TimeSpan, CancellationToken)	Aguarda o Task concluir a execução.
Wait(Int32, CancellationToken)	Aguarda o Task concluir a execução. A espera termina se um intervalo de tempo limite expirar ou um token de cancelamento for cancelado antes que a tarefa seja concluída.
Wait(TimeSpan)	Aguarda o Task concluir a execução dentro de um intervalo especificado.
Wait(CancellationToken)	Aguarda o Task concluir a execução. A espera termina se um token de cancelamento for cancelado antes que a tarefa seja concluída.
Wait()	Aguarda o Task concluir a execução.
Wait(Int32)	Aguarda o Task concluir a execução dentro de um número especificado. de milissegundos.

Wait(TimeSpan, CancellationToken)

Origem:

Task.cs

Aguarda o Task concluir a execução.

C#

public bool Wait (TimeSpan timeout, System.Threading.CancellationToken cancellationToken);

Parâmetros

timeout

TimeSpan

O tempo de espera ou InfiniteTimeSpan aguardar indefinidamente

cancellationToken

CancellationToken

Um CancellationToken a ser observado enquanto aguarda a conclusão da tarefa.

Retornos

Boolean

true se o Task concluiu a execução dentro do tempo determinado; caso contrário, false.

Exceções

AggregateException

O Task foi cancelado

-ou-

uma exceção foi gerada durante a execução do Task.

ArgumentOutOfRangeException

timeout é um número negativo diferente de -1 milissegundos, que representa um tempo limite infinito

-ou-

tempo excedido é maior que MaxValue.

OperationCanceledException

O cancellationToken foi cancelado.

Wait(Int32, CancellationToken)

Origem:

Task.cs

Aguarda o Task concluir a execução. A espera termina se um intervalo de tempo limite expirar ou um token de cancelamento for cancelado antes que a tarefa seja concluída.

C#

public bool Wait (int millisecondsTimeout, System.Threading.CancellationToken cancellationToken);

Parâmetros

millisecondsTimeout

Int32

O número de milissegundos para aguardar ou Infinite (- 1) para aguardar indefinidamente.

cancellationToken

CancellationToken

Um token de cancelamento a ser observado ao aguardar a conclusão da tarefa.

Retornos

Boolean

true se o Task concluiu a execução dentro do tempo determinado; caso contrário, false.

Exceções

OperationCanceledException

O cancellationToken foi cancelado.

ObjectDisposedException

O Task foi descartado.

ArgumentOutOfRangeException

millisecondsTimeout é um número negativo diferente de -1, que representa um tempo limite infinito.

AggregateException

A tarefa foi cancelada. A coleção InnerExceptions contém um objeto TaskCanceledException.

- ou -

Uma exceção foi gerada durante a execução da tarefa. A coleção InnerExceptions contém informações sobre a exceção ou as exceções.

Exemplos

O exemplo a seguir chama o Wait(Int32, CancellationToken) método para fornecer um valor de tempo limite e um token de cancelamento que pode encerrar a espera pela conclusão de uma tarefa. Um novo thread é iniciado e executa o CancelToken método , que pausa e chama o CancellationTokenSource.Cancel método para cancelar os tokens de cancelamento. Em seguida, uma tarefa é iniciada e demora 5 segundos. Em Wait seguida, o método é chamado para aguardar a conclusão da tarefa e recebe um breve valor de tempo limite e um token de cancelamento.

C#

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      CancellationTokenSource ts = new CancellationTokenSource();
      Thread thread = new Thread(CancelToken);
      thread.Start(ts);

      Task t = Task.Run( () => { Task.Delay(5000).Wait();
                                 Console.WriteLine("Task ended delay...");
                               });
      try {
         Console.WriteLine("About to wait completion of task {0}", t.Id);
         bool result = t.Wait(1510, ts.Token);
         Console.WriteLine("Wait completed normally: {0}", result);
         Console.WriteLine("The task status:  {0:G}", t.Status);
      }
      catch (OperationCanceledException e) {
         Console.WriteLine("{0}: The wait has been canceled. Task status: {1:G}",
                           e.GetType().Name, t.Status);
         Thread.Sleep(4000);
         Console.WriteLine("After sleeping, the task status:  {0:G}", t.Status);
         ts.Dispose();
      }
   }

   private static void CancelToken(Object obj)
   {
      Thread.Sleep(1500);
      Console.WriteLine("Canceling the cancellation token from thread {0}...",
                        Thread.CurrentThread.ManagedThreadId);
      CancellationTokenSource source = obj as CancellationTokenSource;
      if (source != null) source.Cancel();
   }
}
// The example displays output like the following if the wait is canceled by
// the cancellation token:
//    About to wait completion of task 1
//    Canceling the cancellation token from thread 3...
//    OperationCanceledException: The wait has been canceled. Task status: Running
//    Task ended delay...
//    After sleeping, the task status:  RanToCompletion
// The example displays output like the following if the wait is canceled by
// the timeout interval expiring:
//    About to wait completion of task 1
//    Wait completed normally: False
//    The task status:  Running
//    Canceling the cancellation token from thread 3...

Observe que a saída precisa do exemplo depende se a espera foi cancelada devido ao token de cancelamento ou porque o intervalo de tempo limite expirou.

Comentários

Wait(Int32, CancellationToken) é um método de sincronização que faz com que o thread de chamada aguarde a conclusão da instância de tarefa atual até que ocorra um destes procedimentos:

• A tarefa é concluída com êxito.

• A tarefa em si é cancelada ou gera uma exceção. Nesse caso, você manipula uma exceção AggregateException . A AggregateException.InnerExceptions propriedade contém detalhes sobre a exceção ou exceções.

• O cancellationToken token de cancelamento é cancelado. Nesse caso, a chamada para o Wait(Int32, CancellationToken) método lança um OperationCanceledException.

• O intervalo definido por millisecondsTimeout decorridos. Nesse caso, o thread atual retoma a execução e o método retorna false.

Observação

Cancelar o cancellationToken token de cancelamento não tem efeito sobre a tarefa em execução, a menos que ele também tenha sido passado o token de cancelamento e esteja preparado para lidar com o cancelamento. Passar o cancellationToken objeto para esse método simplesmente permite que a espera seja cancelada com base em alguma condição.

Wait(TimeSpan)

Origem:

Task.cs

Aguarda o Task concluir a execução dentro de um intervalo especificado.

C#

public bool Wait (TimeSpan timeout);

Parâmetros

timeout

TimeSpan

Um TimeSpan que representa o número de milissegundos para aguardar ou um TimeSpan que representa -1 milissegundos para aguardar indefinidamente.

Retornos

Boolean

true se o Task concluiu a execução dentro do tempo determinado; caso contrário, false.

Exceções

ObjectDisposedException

O Task foi descartado.

ArgumentOutOfRangeException

timeout é um número negativo diferente de -1 milissegundo, que representa um tempo limite infinito.

- ou -

timeout é maior que Int32.MaxValue.

AggregateException

A tarefa foi cancelada. A coleção InnerExceptions contém um objeto TaskCanceledException.

- ou -

Uma exceção foi gerada durante a execução da tarefa. A coleção InnerExceptions contém informações sobre a exceção ou as exceções.

Exemplos

O exemplo a seguir inicia uma tarefa que gera cinco milhões de inteiros aleatórios entre 0 e 100 e calcula sua média. O exemplo usa o Wait(TimeSpan) método para aguardar a conclusão do aplicativo dentro de 150 milissegundos. Se o aplicativo for concluído normalmente, a tarefa exibirá a soma e a média dos números aleatórios gerados. Se o intervalo de tempo limite tiver decorrido, o exemplo exibirá uma mensagem antes de terminar.

C#

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      Task t = Task.Run( () => {
                            Random rnd = new Random();
                            long sum = 0;
                            int n = 5000000;
                            for (int ctr = 1; ctr <= n; ctr++) {
                               int number = rnd.Next(0, 101);
                               sum += number;
                            }
                            Console.WriteLine("Total:   {0:N0}", sum);
                            Console.WriteLine("Mean:    {0:N2}", sum/n);
                            Console.WriteLine("N:       {0:N0}", n);   
                         } );
     TimeSpan ts = TimeSpan.FromMilliseconds(150);
     if (! t.Wait(ts))
        Console.WriteLine("The timeout interval elapsed.");
   }
}
// The example displays output similar to the following:
//       Total:   50,015,714
//       Mean:    50.02
//       N:       1,000,000
// Or it displays the following output:
//      The timeout interval elapsed.

Comentários

Wait(TimeSpan) é um método de sincronização que faz com que o thread de chamada aguarde a conclusão da instância de tarefa atual até que ocorra um destes procedimentos:

• A tarefa é concluída com êxito.

• A tarefa em si é cancelada ou gera uma exceção. Nesse caso, você manipula uma exceção AggregateException . A AggregateException.InnerExceptions propriedade contém detalhes sobre a exceção ou exceções.

• O intervalo definido por timeout decorridos. Nesse caso, o thread atual retoma a execução e o método retorna false.

Wait(CancellationToken)

Origem:

Task.cs

Aguarda o Task concluir a execução. A espera termina se um token de cancelamento for cancelado antes que a tarefa seja concluída.

C#

public void Wait (System.Threading.CancellationToken cancellationToken);

Parâmetros

cancellationToken

CancellationToken

Um token de cancelamento a ser observado ao aguardar a conclusão da tarefa.

Exceções

OperationCanceledException

O cancellationToken foi cancelado.

ObjectDisposedException

A tarefa foi descartada.

AggregateException

A tarefa foi cancelada. A coleção InnerExceptions contém um objeto TaskCanceledException.

- ou -

Uma exceção foi gerada durante a execução da tarefa. A coleção InnerExceptions contém informações sobre a exceção ou as exceções.

Exemplos

O exemplo a seguir ilustra o uso simples de um token de cancelamento para cancelar aguardando a conclusão de uma tarefa. Uma tarefa é iniciada, chama o CancellationTokenSource.Cancel método para cancelar qualquer um dos tokens de cancelamento da origem do token e, em seguida, atrasa por cinco segundos. Observe que a tarefa em si não foi passada para o token de cancelamento e não é cancelável. O thread de aplicativo chama o método da Task.Wait tarefa para aguardar a conclusão da tarefa, mas a espera é cancelada depois que o token de cancelamento é cancelado e um OperationCanceledException é gerado. O manipulador de exceção relata a exceção e, em seguida, dorme por seis segundos. Como mostra a saída do exemplo, esse atraso permite que a tarefa seja concluída no RanToCompletion estado .

C#

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      CancellationTokenSource ts = new CancellationTokenSource();

      Task t = Task.Run( () => { Console.WriteLine("Calling Cancel...");
                                 ts.Cancel();
                                 Task.Delay(5000).Wait();
                                 Console.WriteLine("Task ended delay...");
                               });
      try {
         Console.WriteLine("About to wait for the task to complete...");
         t.Wait(ts.Token);
      }
      catch (OperationCanceledException e) {
         Console.WriteLine("{0}: The wait has been canceled. Task status: {1:G}",
                           e.GetType().Name, t.Status);
         Thread.Sleep(6000);
         Console.WriteLine("After sleeping, the task status:  {0:G}", t.Status);
      }
      ts.Dispose();
   }
}
// The example displays output like the following:
//    About to wait for the task to complete...
//    Calling Cancel...
//    OperationCanceledException: The wait has been canceled. Task status: Running
//    Task ended delay...
//    After sleeping, the task status:  RanToCompletion

Comentários

O Wait(CancellationToken) método cria uma espera cancelável; ou seja, faz com que o thread atual aguarde até que um dos seguintes ocorra:

• A tarefa é concluída.

• O token de cancelamento é cancelado. Nesse caso, a chamada para o Wait(CancellationToken) método lança um OperationCanceledException.

Observação

Cancelar o cancellationToken token de cancelamento não tem efeito sobre a tarefa em execução, a menos que ele também tenha sido passado o token de cancelamento e esteja preparado para lidar com o cancelamento. Passar o cancellationToken objeto para esse método simplesmente permite que a espera seja cancelada.

Wait()

Origem:

Task.cs

Aguarda o Task concluir a execução.

C#

public void Wait ();

Exceções

ObjectDisposedException

O Task foi descartado.

AggregateException

A tarefa foi cancelada. A coleção InnerExceptions contém um objeto TaskCanceledException.

- ou -

Uma exceção foi gerada durante a execução da tarefa. A coleção InnerExceptions contém informações sobre a exceção ou as exceções.

Exemplos

O exemplo a seguir inicia uma tarefa que gera um milhão de inteiros aleatórios entre 0 e 100 e calcula sua média. O exemplo usa o Wait método para garantir que a tarefa seja concluída antes que o aplicativo seja encerrado. Caso contrário, como esse é um aplicativo de console, o exemplo terminaria antes que a tarefa possa calcular e exibir a média.

C#

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      Task t = Task.Run( () => {
                            Random rnd = new Random();
                            long sum = 0;
                            int n = 1000000;
                            for (int ctr = 1; ctr <= n; ctr++) {
                               int number = rnd.Next(0, 101);
                               sum += number;
                            }
                            Console.WriteLine("Total:   {0:N0}", sum);
                            Console.WriteLine("Mean:    {0:N2}", sum/n);
                            Console.WriteLine("N:       {0:N0}", n);   
                         } );
     t.Wait();
   }
}
// The example displays output similar to the following:
//       Total:   50,015,714
//       Mean:    50.02
//       N:       1,000,000

Comentários

Wait é um método de sincronização que faz com que o thread de chamada aguarde até que a tarefa atual seja concluída. Se a tarefa atual não tiver iniciado a execução, o método Wait tentará remover a tarefa do agendador e executá-la embutida no thread atual. Se não for possível fazer isso ou se a tarefa atual já tiver iniciado a execução, ela bloqueará o thread de chamada até que a tarefa seja concluída. Para obter mais informações, consulte Task.Wait e "Inlining" no blog Programação paralela com .NET.

Confira também

• Task.Wait e "Inlining"

Wait(Int32)

Origem:

Task.cs

Aguarda o Task concluir a execução dentro de um número especificado. de milissegundos.

C#

public bool Wait (int millisecondsTimeout);

Parâmetros

millisecondsTimeout

Int32

O número de milissegundos para aguardar ou Infinite (- 1) para aguardar indefinidamente.

Retornos

Boolean

true se o Task concluiu a execução dentro do tempo determinado; caso contrário, false.

Exceções

ObjectDisposedException

O Task foi descartado.

ArgumentOutOfRangeException

millisecondsTimeout é um número negativo diferente de -1, que representa um tempo limite infinito.

AggregateException

A tarefa foi cancelada. A coleção InnerExceptions contém um objeto TaskCanceledException.

- ou -

Uma exceção foi gerada durante a execução da tarefa. A coleção InnerExceptions contém informações sobre a exceção ou as exceções.

Exemplos

O exemplo a seguir inicia uma tarefa que gera cinco milhões de inteiros aleatórios entre 0 e 100 e calcula sua média. O exemplo usa o Wait(Int32) método para aguardar a conclusão do aplicativo dentro de 150 milissegundos. Se o aplicativo for concluído normalmente, a tarefa exibirá a soma e a média dos números aleatórios gerados. Se o intervalo de tempo limite tiver decorrido, o exemplo exibirá uma mensagem antes de terminar.

C#

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      Task t = Task.Run( () => {
                            Random rnd = new Random();
                            long sum = 0;
                            int n = 5000000;
                            for (int ctr = 1; ctr <= n; ctr++) {
                               int number = rnd.Next(0, 101);
                               sum += number;
                            }
                            Console.WriteLine("Total:   {0:N0}", sum);
                            Console.WriteLine("Mean:    {0:N2}", sum/n);
                            Console.WriteLine("N:       {0:N0}", n);   
                         } );
     if (! t.Wait(150))
        Console.WriteLine("The timeout interval elapsed.");
   }
}
// The example displays output similar to the following:
//       Total:   50,015,714
//       Mean:    50.02
//       N:       1,000,000
// Or it displays the following output:
//      The timeout interval elapsed.

Comentários

Wait(Int32) é um método de sincronização que faz com que o thread de chamada aguarde a conclusão da instância de tarefa atual até que ocorra um destes procedimentos:

• A tarefa é concluída com êxito.

• A tarefa em si é cancelada ou gera uma exceção. Nesse caso, você manipula uma exceção AggregateException . A AggregateException.InnerExceptions propriedade contém detalhes sobre a exceção ou exceções.

• O intervalo definido por millisecondsTimeout decorridos. Nesse caso, o thread atual retoma a execução e o método retorna false.