Task.Wait Método

  • Referencia

Definición

Espacio de nombres:
System.Threading.Tasks
Ensamblado:
System.Threading.Tasks.dll
Ensamblado:
System.Runtime.dll
Ensamblado:
mscorlib.dll
Ensamblado:
netstandard.dll

Espera a que se complete la ejecución del objeto Task.

Sobrecargas

Wait()

Espera a que se complete la ejecución del objeto Task.
Wait(Int32)

Espera a que el objeto Task complete la ejecución dentro de un número especificado de milisegundos.
Wait(CancellationToken)

Espera a que se complete la ejecución del objeto Task. La espera finalizará si un token de cancelación se cancela antes de que finalice la tarea.
Wait(TimeSpan)

Espera a que Task complete la ejecución dentro de un intervalo de tiempo especificado.
Wait(Int32, CancellationToken)

Espera a que se complete la ejecución del objeto Task. La espera finalizará si transcurre un intervalo de tiempo de espera o un token de cancelación se cancela antes de que finalice la tarea.
Wait(TimeSpan, CancellationToken)

Espera a que se complete la ejecución del objeto Task.

Wait()

Source:
Task.cs
Source:
Task.cs
Source:
Task.cs

Espera a que se complete la ejecución del objeto Task.

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

Excepciones

ObjectDisposedException

Se ha eliminado Task.

AggregateException

Se canceló la tarea. La colección InnerExceptions contiene un objeto TaskCanceledException.

o bien

Se inició una excepción durante la ejecución de la tarea. La colección InnerExceptions contiene información sobre la excepción o excepciones.

Ejemplos

En el ejemplo siguiente se inicia una tarea que genera un millón de enteros aleatorios entre 0 y 100 y calcula su media. En el ejemplo se usa el Wait método para asegurarse de que la tarea se completa antes de que finalice la aplicación. De lo contrario, dado que se trata de una aplicación de consola, el ejemplo finalizaría antes de que la tarea pueda calcular y mostrar la media.

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

open System
open System.Threading.Tasks

let t =
    Task.Run(fun () ->
        let rnd = Random()
        let mutable sum = 0L
        let n = 1000000

        for _ = 1 to n do
            let number = rnd.Next(0, 101)
            sum <- sum + int64 number

        printfn $"Total:   {sum:N0}"
        printfn $"Mean:    {float sum / float n:N2}"
        printfn $"N:       {n:N0}")

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

Comentarios

Wait es un método de sincronización que hace que el subproceso que realiza la llamada espere hasta que se haya completado la tarea actual. Si la tarea actual no ha iniciado la ejecución, el método Wait intenta quitar la tarea del programador y ejecutarla en línea en el subproceso actual. Si no puede hacerlo o si la tarea actual ya ha iniciado la ejecución, bloquea el subproceso que realiza la llamada hasta que se complete la tarea. Para obtener más información, vea Task.Wait y "Inserción" en el blog Programación en paralelo con .NET.

Consulte también

Se aplica a

Wait(Int32)

Source:
Task.cs
Source:
Task.cs
Source:
Task.cs

Espera a que el objeto Task complete la ejecución dentro de un número especificado de milisegundos.

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

Número de milisegundos de espera o Infinite (-1) para esperar indefinidamente.

Devoluciones

Boolean

true si Task completó su ejecución en el tiempo asignado; en caso contrario, false.

Excepciones

ObjectDisposedException

Se ha eliminado Task.

ArgumentOutOfRangeException

millisecondsTimeout es un número negativo distinto de-1, que representa un tiempo de espera infinito.

AggregateException

Se canceló la tarea. La colección InnerExceptions contiene un objeto TaskCanceledException.

o bien

Se inició una excepción durante la ejecución de la tarea. La colección InnerExceptions contiene información sobre la excepción o excepciones.

Ejemplos

En el ejemplo siguiente se inicia una tarea que genera cinco millones de enteros aleatorios entre 0 y 100 y calcula su media. En el ejemplo se usa el Wait(Int32) método para esperar a que la aplicación se complete en 150 milisegundos. Si la aplicación se completa con normalidad, la tarea muestra la suma y la media de los números aleatorios que ha generado. Si ha transcurrido el intervalo de tiempo de espera, en el ejemplo se muestra un mensaje antes de que finalice.

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.

open System
open System.Threading.Tasks

let t =
    Task.Run(fun () ->
        let rnd = Random()
        let mutable sum = 0L
        let n = 5000000

        for _ = 1 to n do
            let number = rnd.Next(0, 101)
            sum <- sum + int64 number

        printfn $"Total:   {sum:N0}"
        printfn $"Mean:    {float sum / float n:N2}"
        printfn $"N:       {n:N0}")

if t.Wait 150 |> not then
    printfn "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.

Comentarios

Wait(Int32) es un método de sincronización que hace que el subproceso que realiza la llamada espere a que se complete la instancia de tarea actual hasta que se produzca una de las siguientes acciones:

  • La tarea se completa correctamente.

  • La propia tarea se cancela o produce una excepción. En este caso, se controla una AggregateException excepción. La AggregateException.InnerExceptions propiedad contiene detalles sobre la excepción o las excepciones.

  • El intervalo definido por millisecondsTimeout transcurre. En este caso, el subproceso actual reanuda la ejecución y el método devuelve false.

Se aplica a

Wait(CancellationToken)

Source:
Task.cs
Source:
Task.cs
Source:
Task.cs

Espera a que se complete la ejecución del objeto Task. La espera finalizará si un token de cancelación se cancela antes de que finalice la tarea.

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

Parámetros

cancellationToken
CancellationToken

Un token de cancelación que se observará mientras se espera a que se complete la tarea.

Excepciones

OperationCanceledException

cancellationToken se canceló.

ObjectDisposedException

Se ha desechado la tarea.

AggregateException

Se canceló la tarea. La colección InnerExceptions contiene un objeto TaskCanceledException.

o bien

Se inició una excepción durante la ejecución de la tarea. La colección InnerExceptions contiene información sobre la excepción o excepciones.

Ejemplos

En el ejemplo siguiente se muestra el uso simple de un token de cancelación para cancelar a la espera de la finalización de una tarea. Se inicia una tarea, llama al CancellationTokenSource.Cancel método para cancelar cualquiera de los tokens de cancelación del origen del token y, a continuación, retrasa durante cinco segundos. Tenga en cuenta que la propia tarea no se ha pasado el token de cancelación y no se puede cancelar. El subproceso de aplicación llama al método de Task.Wait la tarea para esperar a que se complete la tarea, pero la espera se cancela una vez que se cancela el token de cancelación y se produce una OperationCanceledException excepción . El controlador de excepciones notifica la excepción y, a continuación, se suspende durante seis segundos. Como se muestra en la salida del ejemplo, ese retraso permite que la tarea se complete en el RanToCompletion estado .

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

open System
open System.Threading
open System.Threading.Tasks

let ts = new CancellationTokenSource()

let t =
    Task.Run(fun () ->
        printfn "Calling Cancel..."
        ts.Cancel()
        Task.Delay(5000).Wait()
        printfn $"Task ended delay...")

try
    printfn "About to wait for the task to complete..."
    t.Wait ts.Token

with :? OperationCanceledException as e ->
    printfn $"{e.GetType().Name}: The wait has been canceled. Task status: {t.Status:G}"
    Thread.Sleep 6000
    printfn $"After sleeping, the task status:  {t.Status:G}"

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

Comentarios

El Wait(CancellationToken) método crea una espera cancelable; es decir, hace que el subproceso actual espere hasta que se produzca una de las siguientes acciones:

Nota

Cancelar el cancellationToken token de cancelación no tiene ningún efecto en la tarea en ejecución a menos que también se haya pasado el token de cancelación y esté preparado para controlar la cancelación. Pasar el cancellationToken objeto a este método simplemente permite cancelar la espera.

Se aplica a

Wait(TimeSpan)

Source:
Task.cs
Source:
Task.cs
Source:
Task.cs

Espera a que Task complete la ejecución dentro de un intervalo de tiempo especificado.

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

Estructura TimeSpan que representa el número de milisegundos de espera o estructura TimeSpan que representa -1 milisegundos para esperar indefinidamente.

Devoluciones

Boolean

true si Task completó su ejecución en el tiempo asignado; en caso contrario, false.

Excepciones

ObjectDisposedException

Se ha eliminado Task.

ArgumentOutOfRangeException

timeout es un número negativo distinto de -1 milisegundos, que representa un tiempo de espera infinito.

o bien

timeout es mayor que Int32.MaxValue.

AggregateException

Se canceló la tarea. La colección InnerExceptions contiene un objeto TaskCanceledException.

o bien

Se inició una excepción durante la ejecución de la tarea. La colección InnerExceptions contiene información sobre la excepción o excepciones.

Ejemplos

En el ejemplo siguiente se inicia una tarea que genera cinco millones de enteros aleatorios entre 0 y 100 y calcula su media. En el ejemplo se usa el Wait(TimeSpan) método para esperar a que la aplicación se complete en 150 milisegundos. Si la aplicación se completa con normalidad, la tarea muestra la suma y la media de los números aleatorios que ha generado. Si ha transcurrido el intervalo de tiempo de espera, en el ejemplo se muestra un mensaje antes de que finalice.

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.

open System
open System.Threading.Tasks

let t =
    Task.Run(fun () ->
        let rnd = Random()
        let mutable sum = 0L
        let n = 5000000

        for _ = 1 to n do
            let number = rnd.Next(0, 101)
            sum <- sum + int64 number

        printfn $"Total:   {sum:N0}"
        printfn $"Mean:    {float sum / float n:N2}"
        printfn $"N:       {n:N0}")

let ts = TimeSpan.FromMilliseconds 150

if t.Wait ts |> not then
    printfn "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.

Comentarios

Wait(TimeSpan) es un método de sincronización que hace que el subproceso que realiza la llamada espere a que se complete la instancia de tarea actual hasta que se produzca una de las siguientes acciones:

  • La tarea se completa correctamente.

  • La propia tarea se cancela o produce una excepción. En este caso, se controla una AggregateException excepción. La AggregateException.InnerExceptions propiedad contiene detalles sobre la excepción o las excepciones.

  • El intervalo definido por timeout transcurre. En este caso, el subproceso actual reanuda la ejecución y el método devuelve false.

Se aplica a

Wait(Int32, CancellationToken)

Source:
Task.cs
Source:
Task.cs
Source:
Task.cs

Espera a que se complete la ejecución del objeto Task. La espera finalizará si transcurre un intervalo de tiempo de espera o un token de cancelación se cancela antes de que finalice la tarea.

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
Public Function Wait (millisecondsTimeout As Integer, cancellationToken As CancellationToken) As Boolean

Parámetros

millisecondsTimeout
Int32

Número de milisegundos de espera o Infinite (-1) para esperar indefinidamente.

cancellationToken
CancellationToken

Un token de cancelación que se observará mientras se espera a que se complete la tarea.

Devoluciones

Boolean

true si Task completó su ejecución en el tiempo asignado; en caso contrario, false.

Excepciones

OperationCanceledException

cancellationToken se canceló.

ObjectDisposedException

Se ha eliminado Task.

ArgumentOutOfRangeException

millisecondsTimeout es un número negativo distinto de-1, que representa un tiempo de espera infinito.

AggregateException

Se canceló la tarea. La colección InnerExceptions contiene un objeto TaskCanceledException.

o bien

Se inició una excepción durante la ejecución de la tarea. La colección InnerExceptions contiene información sobre la excepción o excepciones.

Ejemplos

En el ejemplo siguiente se llama al Wait(Int32, CancellationToken) método para proporcionar un valor de tiempo de espera y un token de cancelación que puede finalizar la espera para la finalización de una tarea. Se inicia un nuevo subproceso y ejecuta el CancelToken método , que se detiene y, a continuación, llama al CancellationTokenSource.Cancel método para cancelar los tokens de cancelación. A continuación, se inicia una tarea y se retrasa durante 5 segundos. A Wait continuación, se llama al método para esperar la finalización de la tarea y se proporciona un breve valor de tiempo de espera y un token de cancelación.

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...

open System
open System.Threading
open System.Threading.Tasks

let cancelToken (obj: obj) =
    Thread.Sleep 1500
    printfn $"Canceling the cancellation token from thread {Thread.CurrentThread.ManagedThreadId}..."

    match obj with
    | :? CancellationTokenSource as source -> source.Cancel()
    | _ -> ()

let ts = new CancellationTokenSource()
let thread = Thread(ParameterizedThreadStart cancelToken)
thread.Start ts

let t =
    Task.Run(fun () ->
        Task.Delay(5000).Wait()
        printfn "Task ended delay...")

try
    printfn $"About to wait completion of task {t.Id}"
    let result = t.Wait(1510, ts.Token)
    printfn $"Wait completed normally: {result}"
    printfn $"The task status:  {t.Status:G}"

with :? OperationCanceledException as e ->
    printfn $"{e.GetType().Name}: The wait has been canceled. Task status: {t.Status:G}"
    Thread.Sleep 4000
    printfn $"After sleeping, the task status:  {t.Status:G}"
    ts.Dispose()

// 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...

Tenga en cuenta que la salida precisa del ejemplo depende de si la espera se canceló debido al token de cancelación o porque ha transcurrido el intervalo de tiempo de espera.

Comentarios

Wait(Int32, CancellationToken) es un método de sincronización que hace que el subproceso que realiza la llamada espere a que se complete la instancia de tarea actual hasta que se produzca una de las siguientes acciones:

  • La tarea se completa correctamente.

  • La propia tarea se cancela o produce una excepción. En este caso, se controla una AggregateException excepción. La AggregateException.InnerExceptions propiedad contiene detalles sobre la excepción o las excepciones.

  • El cancellationToken token de cancelación se cancela. En este caso, la llamada al Wait(Int32, CancellationToken) método produce un OperationCanceledException.

  • Intervalo definido por millisecondsTimeout los pasos transcurridos. En este caso, el subproceso actual reanuda la ejecución y el método devuelve false.

Nota

Cancelar el cancellationToken token de cancelación no tiene ningún efecto en la tarea en ejecución a menos que también se haya pasado el token de cancelación y esté preparado para controlar la cancelación. Pasar el cancellationToken objeto a este método simplemente permite cancelar la espera en función de alguna condición.

Se aplica a

Wait(TimeSpan, CancellationToken)

Source:
Task.cs
Source:
Task.cs
Source:
Task.cs

Espera a que se complete la ejecución del objeto Task.

public:
 bool Wait(TimeSpan timeout, System::Threading::CancellationToken cancellationToken);
public bool Wait (TimeSpan timeout, System.Threading.CancellationToken cancellationToken);
member this.Wait : TimeSpan * System.Threading.CancellationToken -> bool
Public Function Wait (timeout As TimeSpan, cancellationToken As CancellationToken) As Boolean

Parámetros

timeout
TimeSpan

El tiempo de espera, o InfiniteTimeSpan para esperar indefinidamente

cancellationToken
CancellationToken

Que CancellationToken se debe observar mientras se espera a que se complete la tarea.

Devoluciones

Boolean

true si Task completó su ejecución en el tiempo asignado; en caso contrario, false.

Excepciones

AggregateException

Task se canceló

o bien

se produjo una excepción durante la ejecución de Task.

ArgumentOutOfRangeException

timeout es un número negativo distinto de -1 milisegundos, que representa un tiempo de espera infinito.

o bien

el tiempo de espera es mayor que MaxValue.

OperationCanceledException

cancellationToken se canceló.

Se aplica a