Task.Wait Task.Wait Task.Wait Task.Wait Method

Definizione

Attende il completamento dell'esecuzione di Task.Waits for the Task to complete execution.

Overload

Wait(TimeSpan) Wait(TimeSpan) Wait(TimeSpan) Wait(TimeSpan)

Attende il completamento dell'esecuzione di Task entro un intervallo di tempo specificato.Waits for the Task to complete execution within a specified time interval.

Wait(Int32, CancellationToken) Wait(Int32, CancellationToken) Wait(Int32, CancellationToken)

Attende il completamento dell'esecuzione di Task.Waits for the Task to complete execution. L'attesa termina se si esaurisce l'intervallo di timeout o se un token di annullamento viene annullato prima del completamento dell'attività.The wait terminates if a timeout interval elapses or a cancellation token is canceled before the task completes.

Wait(CancellationToken) Wait(CancellationToken) Wait(CancellationToken)

Attende il completamento dell'esecuzione di Task.Waits for the Task to complete execution. L'attesa termina se un token di annullamento viene annullato prima del completamento dell'attività.The wait terminates if a cancellation token is canceled before the task completes.

Wait(Int32) Wait(Int32) Wait(Int32) Wait(Int32)

Attende il completamento dell'esecuzione di Task entro un numero specificato di millisecondi.Waits for the Task to complete execution within a specified number of milliseconds.

Wait() Wait() Wait() Wait()

Attende il completamento dell'esecuzione di Task.Waits for the Task to complete execution.

Wait(TimeSpan) Wait(TimeSpan) Wait(TimeSpan) Wait(TimeSpan)

Attende il completamento dell'esecuzione di Task entro un intervallo di tempo specificato.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

Parametri

timeout
TimeSpan TimeSpan TimeSpan TimeSpan

Oggetto TimeSpan che rappresenta il numero di millisecondi di attesa oppure TimeSpan che rappresenta -1 millisecondi per un'attesa indefinita.A TimeSpan that represents the number of milliseconds to wait, or a TimeSpan that represents -1 milliseconds to wait indefinitely.

Restituisce

true se Task ha completato l'esecuzione nel tempo consentito; in caso contrario, false.true if the Task completed execution within the allotted time; otherwise, false.

Eccezioni

timeout è un numero negativo diverso da -1 millisecondi, che rappresenta un timeout infinito.timeout is a negative number other than -1 milliseconds, which represents an infinite time-out. -oppure--or- timeout è maggiore di MaxValue.timeout is greater than MaxValue.

L'attività è stata annullata.The task was canceled. La raccolta InnerExceptions contiene un oggetto TaskCanceledException.The InnerExceptions collection contains a TaskCanceledException object.

-oppure--or- È stata generata un'eccezione durante l'esecuzione dell'attività.An exception was thrown during the execution of the task. La raccolta InnerExceptions contiene informazioni su una o più eccezioni.The InnerExceptions collection contains information about the exception or exceptions.

Esempi

Nell'esempio seguente avvia un'attività che genera numeri interi casuali di cinque milioni compreso tra 0 e 100 e calcola la Media.The following example starts a task that generates five million random integers between 0 and 100 and computes their mean. Nell'esempio viene usato il Wait(TimeSpan) metodo per attendere che l'applicazione viene completata entro 150 millisecondi.The example uses the Wait(TimeSpan) method to wait for the application to complete within 150 milliseconds. Se l'applicazione viene in genere, l'attività Visualizza la somma e Media dei numeri casuali che lo ha generato.If the application completes normally, the task displays the sum and mean of the random numbers that it has generated. Se è trascorso l'intervallo di timeout, l'esempio visualizza un messaggio prima che venga terminato.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.

Commenti

Wait(TimeSpan) è un metodo di sincronizzazione che fa sì che il thread chiamante di attesa per l'istanza corrente di attività da completare fino a quando non si verifica una delle operazioni seguenti: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:

  • L'attività viene completata correttamente.The task completes successfully.

  • L'attività viene annullata o genera un'eccezione.The task itself is canceled or throws an exception. In questo caso, si gestisce un AggregateException eccezione.In this case, you handle an AggregateException exception. Il AggregateException.InnerExceptions proprietà contiene informazioni dettagliate su una o più eccezioni.The AggregateException.InnerExceptions property contains details about the exception or exceptions.

  • L'intervallo definito da timeout scade.The interval defined by timeout elapses. In questo caso, il thread corrente viene ripresa l'esecuzione e il metodo restituisce false.In this case, the current thread resumes execution and the method returns false.

Wait(Int32, CancellationToken) Wait(Int32, CancellationToken) Wait(Int32, CancellationToken)

Attende il completamento dell'esecuzione di Task.Waits for the Task to complete execution. L'attesa termina se si esaurisce l'intervallo di timeout o se un token di annullamento viene annullato prima del completamento dell'attività.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

Parametri

millisecondsTimeout
Int32 Int32 Int32 Int32

Numero di millisecondi di attesa oppure Infinite (-1) per un'attesa indefinita.The number of milliseconds to wait, or Infinite (-1) to wait indefinitely.

cancellationToken
CancellationToken CancellationToken CancellationToken CancellationToken

Token di annullamento da osservare durante l'attesa del completamento dell'attività.A cancellation token to observe while waiting for the task to complete.

Restituisce

true se Task ha completato l'esecuzione nel tempo consentito; in caso contrario, false.true if the Task completed execution within the allotted time; otherwise, false.

Eccezioni

Il parametro cancellationToken è stato annullato.The cancellationToken was canceled.

millisecondsTimeout è un numero negativo diverso da -1, che rappresenta un timeout infinito.millisecondsTimeout is a negative number other than -1, which represents an infinite time-out.

L'attività è stata annullata.The task was canceled. La raccolta InnerExceptions contiene un oggetto TaskCanceledException.The InnerExceptions collection contains a TaskCanceledException object.

-oppure--or- È stata generata un'eccezione durante l'esecuzione dell'attività.An exception was thrown during the execution of the task. La raccolta InnerExceptions contiene informazioni su una o più eccezioni.The InnerExceptions collection contains information about the exception or exceptions.

Esempi

L'esempio seguente chiama il Wait(Int32, CancellationToken) metodo per fornire un valore di timeout sia un annullamento dei token che può terminare il completamento dell'attività attesa.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. Un nuovo thread viene avviato ed esegue la CancelToken metodo, che sospende e quindi chiama il CancellationTokenSource.Cancel metodo per annullare il token di annullamento.A new thread is started and executes the CancelToken method, which pauses and then calls the CancellationTokenSource.Cancel method to cancel the cancellation tokens. Un'attività viene quindi avviata e ritarda per 5 secondi.A task is then launched and delays for 5 seconds. Il Wait metodo per attendere il completamento dell'attività viene quindi chiamato e viene fornito un valore di timeout breve sia un token di annullamento.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...

Si noti che l'output dell'esempio preciso dipende se l'attesa è stata annullata a causa di token di annullamento o perché l'intervallo di timeout è scaduto.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.

Commenti

Wait(Int32, CancellationToken) è un metodo di sincronizzazione che fa sì che il thread chiamante di attesa per l'istanza corrente di attività da completare fino a quando non si verifica una delle operazioni seguenti: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:

  • L'attività viene completata correttamente.The task completes successfully.

  • L'attività viene annullata o genera un'eccezione.The task itself is canceled or throws an exception. In questo caso, si gestisce un AggregateException eccezione.In this case, you handle an AggregateException exception. Il AggregateException.InnerExceptions proprietà contiene informazioni dettagliate su una o più eccezioni.The AggregateException.InnerExceptions property contains details about the exception or exceptions.

  • Il cancellationToken token di annullamento.The cancellationToken cancellation token is canceled. In questo caso, la chiamata per il Wait(Int32, CancellationToken) metodo genera un OperationCanceledException.In this case, the call to the Wait(Int32, CancellationToken) method throws an OperationCanceledException.

  • L'intervallo definito da millisecondsTimeout scade.The interval defined by millisecondsTimeout elapses. In questo caso, il thread corrente viene ripresa l'esecuzione e il metodo restituisce false.In this case, the current thread resumes execution and the method returns false.

Nota

Annullamento di cancellationToken token di annullamento non ha alcun effetto sull'attività in esecuzione a meno che non lo è anche stato passato il token di annullamento e si è preparato a gestire l'annullamento.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. Passando il cancellationToken oggetto al metodo semplicemente consente l'attesa deve essere annullata in base una condizione.Passing the cancellationToken object to this method simply allows the wait to be canceled based on some condition.

Wait(CancellationToken) Wait(CancellationToken) Wait(CancellationToken)

Attende il completamento dell'esecuzione di Task.Waits for the Task to complete execution. L'attesa termina se un token di annullamento viene annullato prima del completamento dell'attività.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

Parametri

cancellationToken
CancellationToken CancellationToken CancellationToken CancellationToken

Token di annullamento da osservare durante l'attesa del completamento dell'attività.A cancellation token to observe while waiting for the task to complete.

Eccezioni

Il parametro cancellationToken è stato annullato.The cancellationToken was canceled.

L'attività è stata eliminata.The task has been disposed.

L'attività è stata annullata.The task was canceled. La raccolta InnerExceptions contiene un oggetto TaskCanceledException.The InnerExceptions collection contains a TaskCanceledException object.

-oppure--or- È stata generata un'eccezione durante l'esecuzione dell'attività.An exception was thrown during the execution of the task. La raccolta InnerExceptions contiene informazioni su una o più eccezioni.The InnerExceptions collection contains information about the exception or exceptions.

Esempi

Nell'esempio seguente viene illustrato l'utilizzo semplice dei token di annullamento per annullare l'attesa del completamento dell'attività.The following example illustrates the simple use of a cancellation token to cancel waiting for a task's completion. Un'attività viene avviata, le chiamate di CancellationTokenSource.Cancel metodo per annullare una qualsiasi di token di annullamento dell'origine del token, quindi ritardi per cinque secondi.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. Si noti che l'attività stessa non è stato passato il token di annullamento e non può essere annullata.Note that the task itself has not been passed the cancellation token and is not cancelable. Il thread dell'applicazione chiama l'attività Task.Wait metodo per attendere il completamento dell'attività, ma il tempo di attesa viene annullato quando il token di annullamento viene annullato e un OperationCanceledException viene generata un'eccezione.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. Il gestore di eccezioni segnala l'eccezione e quindi rimane inattivo per sei secondi.The exception handler reports the exception and then sleeps for six seconds. Come illustrato nell'output dell'esempio, questo ritardo consente all'attività da completare nella RanToCompletion dello stato.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

Commenti

Il Wait(CancellationToken) metodo crea un'attesa annullabile; vale a dire, il thread corrente di attesa fino a quando non si verifica una delle operazioni seguenti:The Wait(CancellationToken) method creates a cancelable wait; that is, it causes the current thread to wait until one of the following occurs:

Nota

Annullamento di cancellationToken token di annullamento non ha alcun effetto sull'attività in esecuzione a meno che non lo è anche stato passato il token di annullamento e si è preparato a gestire l'annullamento.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. Passando il cancellationToken oggetti a questo metodo consente semplicemente l'attesa deve essere annullata.Passing the cancellationToken object to this method simply allows the wait to be canceled.

Wait(Int32) Wait(Int32) Wait(Int32) Wait(Int32)

Attende il completamento dell'esecuzione di Task entro un numero specificato di millisecondi.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

Parametri

millisecondsTimeout
Int32 Int32 Int32 Int32

Numero di millisecondi di attesa oppure Infinite (-1) per un'attesa indefinita.The number of milliseconds to wait, or Infinite (-1) to wait indefinitely.

Restituisce

true se Task ha completato l'esecuzione nel tempo consentito; in caso contrario, false.true if the Task completed execution within the allotted time; otherwise, false.

Eccezioni

millisecondsTimeout è un numero negativo diverso da -1, che rappresenta un timeout infinito.millisecondsTimeout is a negative number other than -1, which represents an infinite time-out.

L'attività è stata annullata.The task was canceled. La raccolta InnerExceptions contiene un oggetto TaskCanceledException.The InnerExceptions collection contains a TaskCanceledException object.

-oppure--or- È stata generata un'eccezione durante l'esecuzione dell'attività.An exception was thrown during the execution of the task. La raccolta InnerExceptions contiene informazioni su una o più eccezioni.The InnerExceptions collection contains information about the exception or exceptions.

Esempi

Nell'esempio seguente avvia un'attività che genera numeri interi casuali di cinque milioni compreso tra 0 e 100 e calcola la Media.The following example starts a task that generates five million random integers between 0 and 100 and computes their mean. Nell'esempio viene usato il Wait(Int32) metodo per attendere che l'applicazione viene completata entro 150 millisecondi.The example uses the Wait(Int32) method to wait for the application to complete within 150 milliseconds. Se l'applicazione viene in genere, l'attività Visualizza la somma e Media dei numeri casuali che lo ha generato.If the application completes normally, the task displays the sum and mean of the random numbers that it has generated. Se è trascorso l'intervallo di timeout, l'esempio visualizza un messaggio prima che venga terminato.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.

Commenti

Wait(Int32) è un metodo di sincronizzazione che fa sì che il thread chiamante di attesa per l'istanza corrente di attività da completare fino a quando non si verifica una delle operazioni seguenti: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:

  • L'attività viene completata correttamente.The task completes successfully.

  • L'attività viene annullata o genera un'eccezione.The task itself is canceled or throws an exception. In questo caso, si gestisce un AggregateException eccezione.In this case, you handle an AggregateException exception. Il AggregateException.InnerExceptions proprietà contiene informazioni dettagliate su una o più eccezioni.The AggregateException.InnerExceptions property contains details about the exception or exceptions.

  • L'intervallo definito da millisecondsTimeout scade.The interval defined by millisecondsTimeout elapses. In questo caso, il thread corrente viene ripresa l'esecuzione e il metodo restituisce false.In this case, the current thread resumes execution and the method returns false.

Wait() Wait() Wait() Wait()

Attende il completamento dell'esecuzione di Task.Waits for the Task to complete execution.

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

Eccezioni

L'attività è stata annullata.The task was canceled. La raccolta InnerExceptions contiene un oggetto TaskCanceledException.The InnerExceptions collection contains a TaskCanceledException object.

-oppure--or- È stata generata un'eccezione durante l'esecuzione dell'attività.An exception was thrown during the execution of the task. La raccolta InnerExceptions contiene informazioni su una o più eccezioni.The InnerExceptions collection contains information about the exception or exceptions.

Esempi

Nell'esempio seguente avvia un'attività che genera un milione di integer casuale compreso tra 0 e 100 e calcola la Media.The following example starts a task that generates one million random integers between 0 and 100 and computes their mean. Nell'esempio viene usato il Wait metodo per assicurarsi che l'attività venga completata prima che l'applicazione viene terminata.The example uses the Wait method to ensure that the task completes before the application terminates. In caso contrario, poiché si tratta di un'applicazione console, l'esempio interrompe prima che l'attività può calcolare e visualizzare il valore medio.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

Commenti

Wait è un metodo di sincronizzazione che fa sì che il thread chiamante attendere il completamento dell'attività corrente.Wait is a synchronization method that causes the calling thread to wait until the current task has completed. Se l'attività corrente non ha avviato l'esecuzione, il metodo Wait tenta di rimuovere l'attività dall'utilità di pianificazione ed eseguirlo inline nel thread corrente.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 non è possibile eseguire questa operazione, oppure se l'attività corrente è già avviato l'esecuzione, si blocca il thread chiamante fino al completamento dell'attività.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. Per altre informazioni, vedere Task.Wait e "Inline" nella programmazione parallela con .NET blog.For more information, see Task.Wait and "Inlining" in the Parallel Programming with .NET blog.

Vedi anche

Si applica a