Task.Wait Método

Definição

Aguarda o Task concluir a execução.Waits for the Task to complete execution.

Sobrecargas

Wait(TimeSpan)

Aguarda o Task concluir a execução dentro de um intervalo especificado.Waits for the Task to complete execution within a specified time interval.

Wait(Int32, CancellationToken)

Aguarda o Task concluir a execução.Waits for the Task to complete execution. A espera termina se um intervalo de tempo limite expirar ou um token de cancelamento for cancelado antes que a tarefa seja concluída.The wait terminates if a timeout interval elapses or a cancellation token is canceled before the task completes.

Wait(CancellationToken)

Aguarda o Task concluir a execução.Waits for the Task to complete execution. A espera termina se um token de cancelamento for cancelado antes que a tarefa seja concluída.The wait terminates if a cancellation token is canceled before the task completes.

Wait(Int32)

Aguarda o Task concluir a execução dentro de um número especificado. de milissegundos.Waits for the Task to complete execution within a specified number of milliseconds.

Wait()

Aguarda o Task concluir a execução.Waits for the Task to complete execution.

Wait(TimeSpan)

Aguarda o Task concluir a execução dentro de um intervalo especificado.Waits for the Task to complete execution within a specified time interval.

public:
 bool Wait(TimeSpan timeout);
public bool Wait (TimeSpan timeout);
member this.Wait : TimeSpan -> bool
Public Function Wait (timeout As TimeSpan) As Boolean

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.A TimeSpan that represents the number of milliseconds to wait, or a TimeSpan that represents -1 milliseconds to wait indefinitely.

Retornos

true se o Task concluiu a execução dentro do tempo determinado; caso contrário, false.true if the Task completed execution within the allotted time; otherwise, false.

Exceções

O Task foi descartado.The Task has been disposed.

timeout é um número negativo diferente de -1 milissegundo, que representa um tempo limite infinito.timeout is a negative number other than -1 milliseconds, which represents an infinite time-out. - ou --or- timeout é maior que MaxValue.timeout is greater than MaxValue.

A tarefa foi cancelada.The task was canceled. A coleção InnerExceptions contém um objeto TaskCanceledException.The InnerExceptions collection contains a TaskCanceledException object.

- ou --or- Uma exceção foi gerada durante a execução da tarefa.An exception was thrown during the execution of the task. A coleção InnerExceptions contém informações sobre a exceção ou as exceções.The InnerExceptions collection contains information about the exception or exceptions.

Exemplos

O exemplo a seguir inicia uma tarefa que gera números inteiros aleatórios de 5 milhões entre 0 e 100 e calcula sua média.The following example starts a task that generates five million random integers between 0 and 100 and computes their mean. O exemplo usa o método Wait(TimeSpan) para aguardar a conclusão do aplicativo dentro de 150 milissegundos.The example uses the Wait(TimeSpan) method to wait for the application to complete within 150 milliseconds. Se o aplicativo for concluído normalmente, a tarefa exibirá a soma e a média dos números aleatórios gerados.If the application completes normally, the task displays the sum and mean of the random numbers that it has generated. Se o intervalo de tempo limite tiver decorrido, o exemplo exibirá uma mensagem antes de ser encerrado.If the timeout interval has elapsed, the example displays a message before it terminates.

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.
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim t As Task = Task.Run( Sub()
                                   Dim rnd As New Random()
                                   Dim sum As Long
                                   Dim n As Integer = 5000000
                                   For ctr As Integer = 1 To n
                                      Dim number As Integer = rnd.Next(0, 101)
                                      sum += number
                                   Next
                                   Console.WriteLine("Total:   {0:N0}", sum)
                                   Console.WriteLine("Mean:    {0:N2}", sum/n)
                                   Console.WriteLine("N:       {0:N0}", n)   
                                End Sub)
     Dim ts As TimeSpan = TimeSpan.FromMilliseconds(150)
     If Not t.Wait(ts) Then
        Console.WriteLine("The timeout interval elapsed.")
     End If
   End Sub
End Module
' 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 até que a instância de tarefa atual seja concluída até que ocorra um dos seguintes:Wait(TimeSpan) is a synchronization method that causes the calling thread to wait for the current task instance to complete until one of the following occurs:

  • A tarefa é concluída com êxito.The task completes successfully.

  • A própria tarefa é cancelada ou gera uma exceção.The task itself is canceled or throws an exception. Nesse caso, você manipula uma exceção AggregateException.In this case, you handle an AggregateException exception. A propriedade AggregateException.InnerExceptions contém detalhes sobre a exceção ou exceções.The AggregateException.InnerExceptions property contains details about the exception or exceptions.

  • O intervalo definido por timeout decorre.The interval defined by timeout elapses. Nesse caso, o thread atual retoma a execução e o método retorna false.In this case, the current thread resumes execution and the method returns false.

Wait(Int32, CancellationToken)

Aguarda o Task concluir a execução.Waits for the Task to complete execution. A espera termina se um intervalo de tempo limite expirar ou um token de cancelamento for cancelado antes que a tarefa seja concluída.The wait terminates if a timeout interval elapses or a cancellation token is canceled before the task completes.

public:
 bool Wait(int millisecondsTimeout, System::Threading::CancellationToken cancellationToken);
public bool Wait (int millisecondsTimeout, System.Threading.CancellationToken cancellationToken);
member this.Wait : int * System.Threading.CancellationToken -> bool

Parâmetros

millisecondsTimeout
Int32

O número de milissegundos para aguardar ou Infinite (- 1) para aguardar indefinidamente.The number of milliseconds to wait, or Infinite (-1) to wait indefinitely.

cancellationToken
CancellationToken

Um token de cancelamento a ser observado ao aguardar a conclusão da tarefa.A cancellation token to observe while waiting for the task to complete.

Retornos

true se o Task concluiu a execução dentro do tempo determinado; caso contrário, false.true if the Task completed execution within the allotted time; otherwise, false.

Exceções

O cancellationToken foi cancelado.The cancellationToken was canceled.

O Task foi descartado.The Task has been disposed.

millisecondsTimeout é um número negativo diferente de -1, que representa um tempo limite infinito.millisecondsTimeout is a negative number other than -1, which represents an infinite time-out.

A tarefa foi cancelada.The task was canceled. A coleção InnerExceptions contém um objeto TaskCanceledException.The InnerExceptions collection contains a TaskCanceledException object.

- ou --or- Uma exceção foi gerada durante a execução da tarefa.An exception was thrown during the execution of the task. A coleção InnerExceptions contém informações sobre a exceção ou as exceções.The InnerExceptions collection contains information about the exception or exceptions.

Exemplos

O exemplo a seguir chama o método Wait(Int32, CancellationToken) para fornecer um valor de tempo limite e um token de cancelamento que podem terminar a espera para a conclusão de uma tarefa.The following example calls the Wait(Int32, CancellationToken) method to provide both a timeout value and a cancellation token that can end the wait for a task's completion. Um novo thread é iniciado e executa o método CancelToken, que pausa e, em seguida, chama o método CancellationTokenSource.Cancel para cancelar os tokens de cancelamento.A new thread is started and executes the CancelToken method, which pauses and then calls the CancellationTokenSource.Cancel method to cancel the cancellation tokens. Uma tarefa é então iniciada e atrasa por 5 segundos.A task is then launched and delays for 5 seconds. O método Wait é chamado para aguardar a conclusão da tarefa e é fornecido um valor de tempo limite curto e um token de cancelamento.The Wait method is then called to wait for the task's completion and is provided both a brief timeout value and a cancellation token.

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...
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim ts As New CancellationTokenSource()
      Dim thread As New Thread(AddressOf CancelToken)
      thread.Start(ts)

      Dim t As Task = Task.Run( Sub()
                                   Task.Delay(5000).Wait()
                                    Console.WriteLine("Task ended delay...")
                                End Sub)
      Try
         Console.WriteLine("About to wait completion of task {0}", t.Id)
         Dim result As Boolean = t.Wait(1510, ts.Token)
         Console.WriteLine("Wait completed normally: {0}", result)
         Console.WriteLine("The task status:  {0:G}", t.Status)
      Catch e As OperationCanceledException
         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()
      End Try
   End Sub

   Private Sub CancelToken(obj As Object)
      Thread.Sleep(1500)
      Console.WriteLine("Canceling the cancellation token from thread {0}...",
                        Thread.CurrentThread.ManagedThreadId)

      If TypeOf obj Is CancellationTokenSource Then
         Dim source As CancellationTokenSource = CType(obj, CancellationTokenSource)
         source.Cancel()
      End If
   End Sub
End Module
' 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 foi decorrido.Note that the precise output from the example depends on whether the wait was canceled because of the cancellation token or because the timeout interval elapsed.

Comentários

Wait(Int32, CancellationToken) é um método de sincronização que faz com que o thread de chamada aguarde até que a instância de tarefa atual seja concluída até que ocorra um dos seguintes:Wait(Int32, CancellationToken) is a synchronization method that causes the calling thread to wait for the current task instance to complete until one of the following occurs:

Observação

Cancelar o token de cancelamento de cancellationToken não tem efeito sobre a tarefa em execução, a menos que também tenha passado o token de cancelamento e esteja preparado para lidar com cancelamento.Canceling the cancellationToken cancellation token has no effect on the running task unless it has also been passed the cancellation token and is prepared to handle cancellation. Passar o objeto cancellationToken para esse método simplesmente permite que a espera seja cancelada com base em alguma condição.Passing the cancellationToken object to this method simply allows the wait to be canceled based on some condition.

Wait(CancellationToken)

Aguarda o Task concluir a execução.Waits for the Task to complete execution. A espera termina se um token de cancelamento for cancelado antes que a tarefa seja concluída.The wait terminates if a cancellation token is canceled before the task completes.

public:
 void Wait(System::Threading::CancellationToken cancellationToken);
public void Wait (System.Threading.CancellationToken cancellationToken);
member this.Wait : System.Threading.CancellationToken -> unit

Parâmetros

cancellationToken
CancellationToken

Um token de cancelamento a ser observado ao aguardar a conclusão da tarefa.A cancellation token to observe while waiting for the task to complete.

Exceções

O cancellationToken foi cancelado.The cancellationToken was canceled.

A tarefa foi descartada.The task has been disposed.

A tarefa foi cancelada.The task was canceled. A coleção InnerExceptions contém um objeto TaskCanceledException.The InnerExceptions collection contains a TaskCanceledException object.

- ou --or- Uma exceção foi gerada durante a execução da tarefa.An exception was thrown during the execution of the task. A coleção InnerExceptions contém informações sobre a exceção ou as exceções.The InnerExceptions collection contains information about the exception or exceptions.

Exemplos

O exemplo a seguir ilustra o uso simples de um token de cancelamento para cancelar a espera pela conclusão de uma tarefa.The following example illustrates the simple use of a cancellation token to cancel waiting for a task's completion. Uma tarefa é iniciada, chama o método CancellationTokenSource.Cancel para cancelar qualquer um dos tokens de cancelamento da origem do token e, em seguida, atrasa por cinco segundos.A task is launched, calls the CancellationTokenSource.Cancel method to cancel any of the token source's cancellation tokens, and then delays for five seconds. Observe que a tarefa em si não passou o token de cancelamento e não é cancelável.Note that the task itself has not been passed the cancellation token and is not cancelable. O thread do aplicativo chama o método Task.Wait da tarefa para aguardar a conclusão da tarefa, mas a espera é cancelada quando o token de cancelamento é cancelado e um OperationCanceledException é gerado.The application thread calls the task's Task.Wait method to wait for the task to complete, but the wait is canceled once the cancellation token is cancelled and an OperationCanceledException is thrown. O manipulador de exceção relata a exceção e, em seguida, dorme por seis segundos.The exception handler reports the exception and then sleeps for six seconds. Como a saída do exemplo mostra, esse atraso permite que a tarefa seja concluída no estado RanToCompletion.As the output from the example shows, that delay allows the task to complete in the RanToCompletion state.

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
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim ts As New CancellationTokenSource()

      Dim t = Task.Run( Sub()
                           Console.WriteLine("Calling Cancel...")
                           ts.Cancel()
                           Task.Delay(5000).Wait()
                           Console.WriteLine("Task ended delay...")
                        End Sub)
      Try
         Console.WriteLine("About to wait for the task to complete...")
         t.Wait(ts.Token)
      Catch e As OperationCanceledException
         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)
      End Try
      ts.Dispose()
   End Sub
End Module
' 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 método Wait(CancellationToken) cria uma espera cancelável; ou seja, faz com que o thread atual aguarde até que ocorra um dos seguintes:The Wait(CancellationToken) method creates a cancelable wait; that is, it causes the current thread to wait until one of the following occurs:

Observação

Cancelar o token de cancelamento de cancellationToken não tem efeito sobre a tarefa em execução, a menos que também tenha passado o token de cancelamento e esteja preparado para lidar com cancelamento.Canceling the cancellationToken cancellation token has no effect on the running task unless it has also been passed the cancellation token and is prepared to handle cancellation. Passar o objeto cancellationToken para esse método simplesmente permite que a espera seja cancelada.Passing the cancellationToken object to this method simply allows the wait to be canceled.

Wait(Int32)

Aguarda o Task concluir a execução dentro de um número especificado. de milissegundos.Waits for the Task to complete execution within a specified number of milliseconds.

public:
 bool Wait(int millisecondsTimeout);
public bool Wait (int millisecondsTimeout);
member this.Wait : int -> bool
Public Function Wait (millisecondsTimeout As Integer) As Boolean

Parâmetros

millisecondsTimeout
Int32

O número de milissegundos para aguardar ou Infinite (- 1) para aguardar indefinidamente.The number of milliseconds to wait, or Infinite (-1) to wait indefinitely.

Retornos

true se o Task concluiu a execução dentro do tempo determinado; caso contrário, false.true if the Task completed execution within the allotted time; otherwise, false.

Exceções

O Task foi descartado.The Task has been disposed.

millisecondsTimeout é um número negativo diferente de -1, que representa um tempo limite infinito.millisecondsTimeout is a negative number other than -1, which represents an infinite time-out.

A tarefa foi cancelada.The task was canceled. A coleção InnerExceptions contém um objeto TaskCanceledException.The InnerExceptions collection contains a TaskCanceledException object.

- ou --or- Uma exceção foi gerada durante a execução da tarefa.An exception was thrown during the execution of the task. A coleção InnerExceptions contém informações sobre a exceção ou as exceções.The InnerExceptions collection contains information about the exception or exceptions.

Exemplos

O exemplo a seguir inicia uma tarefa que gera números inteiros aleatórios de 5 milhões entre 0 e 100 e calcula sua média.The following example starts a task that generates five million random integers between 0 and 100 and computes their mean. O exemplo usa o método Wait(Int32) para aguardar a conclusão do aplicativo dentro de 150 milissegundos.The example uses the Wait(Int32) method to wait for the application to complete within 150 milliseconds. Se o aplicativo for concluído normalmente, a tarefa exibirá a soma e a média dos números aleatórios gerados.If the application completes normally, the task displays the sum and mean of the random numbers that it has generated. Se o intervalo de tempo limite tiver decorrido, o exemplo exibirá uma mensagem antes de ser encerrado.If the timeout interval has elapsed, the example displays a message before it terminates.

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.
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim t As Task = Task.Run( Sub()
                                   Dim rnd As New Random()
                                   Dim sum As Long
                                   Dim n As Integer = 5000000
                                   For ctr As Integer = 1 To n
                                      Dim number As Integer = rnd.Next(0, 101)
                                      sum += number
                                   Next
                                   Console.WriteLine("Total:   {0:N0}", sum)
                                   Console.WriteLine("Mean:    {0:N2}", sum/n)
                                   Console.WriteLine("N:       {0:N0}", n)   
                                End Sub)
     If Not t.Wait(150) Then
        Console.WriteLine("The timeout interval elapsed.")
     End If
   End Sub
End Module
' 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 até que a instância de tarefa atual seja concluída até que ocorra um dos seguintes:Wait(Int32) is a synchronization method that causes the calling thread to wait for the current task instance to complete until one of the following occurs:

  • A tarefa é concluída com êxito.The task completes successfully.

  • A própria tarefa é cancelada ou gera uma exceção.The task itself is canceled or throws an exception. Nesse caso, você manipula uma exceção AggregateException.In this case, you handle an AggregateException exception. A propriedade AggregateException.InnerExceptions contém detalhes sobre a exceção ou exceções.The AggregateException.InnerExceptions property contains details about the exception or exceptions.

  • O intervalo definido por millisecondsTimeout decorre.The interval defined by millisecondsTimeout elapses. Nesse caso, o thread atual retoma a execução e o método retorna false.In this case, the current thread resumes execution and the method returns false.

Wait()

Aguarda o Task concluir a execução.Waits for the Task to complete execution.

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

Exceções

O Task foi descartado.The Task has been disposed.

A tarefa foi cancelada.The task was canceled. A coleção InnerExceptions contém um objeto TaskCanceledException.The InnerExceptions collection contains a TaskCanceledException object.

- ou --or- Uma exceção foi gerada durante a execução da tarefa.An exception was thrown during the execution of the task. A coleção InnerExceptions contém informações sobre a exceção ou as exceções.The InnerExceptions collection contains information about the exception or exceptions.

Exemplos

O exemplo a seguir inicia uma tarefa que gera números inteiros aleatórios de 1 milhão entre 0 e 100 e calcula sua média.The following example starts a task that generates one million random integers between 0 and 100 and computes their mean. O exemplo usa o método Wait para garantir que a tarefa seja concluída antes de o aplicativo ser encerrado.The example uses the Wait method to ensure that the task completes before the application terminates. Caso contrário, como esse é um aplicativo de console, o exemplo será encerrado antes que a tarefa possa calcular e exibir a média.Otherwise, because this is a console application, the example would terminate before the task can compute and display the mean.

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
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim t As Task = Task.Run( Sub()
                                   Dim rnd As New Random()
                                   Dim sum As Long
                                   Dim n As Integer = 1000000
                                   For ctr As Integer = 1 To n
                                      Dim number As Integer = rnd.Next(0, 101)
                                      sum += number
                                   Next
                                   Console.WriteLine("Total:   {0:N0}", sum)
                                   Console.WriteLine("Mean:    {0:N2}", sum/n)
                                   Console.WriteLine("N:       {0:N0}", n)   
                                End Sub)
     t.Wait()
   End Sub
End Module
' 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.Wait is a synchronization method that causes the calling thread to wait until the current task has completed. 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.If the current task has not started execution, the Wait method attempts to remove the task from the scheduler and execute it inline on the current thread. 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.If it is unable to do that, or if the current task has already started execution, it blocks the calling thread until the task completes. Para obter mais informações, consulte Task. Wait e "Outlining" no blog sobre programação paralela com .net.For more information, see Task.Wait and "Inlining" in the Parallel Programming with .NET blog.

Veja também

Aplica-se a