Task.Delay Método

public:
 static System::Threading::Tasks::Task ^ Delay(TimeSpan delay, System::Threading::CancellationToken cancellationToken);

public static System.Threading.Tasks.Task Delay(TimeSpan delay, System.Threading.CancellationToken cancellationToken);

static member Delay : TimeSpan * System.Threading.CancellationToken -> System.Threading.Tasks.Task

Public Shared Function Delay (delay As TimeSpan, cancellationToken As CancellationToken) As Task

Parâmetros

Devoluções

Uma tarefa que representa o atraso temporal.

Exceções

Exemplos

O exemplo seguinte lança uma tarefa que inclui uma chamada ao Delay(TimeSpan, CancellationToken) método com um atraso de 1,5 segundos. Antes do intervalo de atraso terminar, o token é cancelado. A saída do exemplo mostra que, como resultado, um TaskCanceledException é lançado, e a propriedade das Status tarefas é definida para Canceled.

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

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

      var t = Task.Run(async delegate
              {
                 await Task.Delay(TimeSpan.FromSeconds(1.5), source.Token);
                 return 42;
              });
      source.Cancel();
      try {
         t.Wait();
      }
      catch (AggregateException ae) {
         foreach (var e in ae.InnerExceptions)
            Console.WriteLine("{0}: {1}", e.GetType().Name, e.Message);
      }
      Console.Write("Task t Status: {0}", t.Status);
      if (t.Status == TaskStatus.RanToCompletion)
         Console.Write(", Result: {0}", t.Result);
      source.Dispose();
   }
}
// The example displays output like the following:
//       TaskCanceledException: A task was canceled.
//       Task t Status: Canceled

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

let source = new CancellationTokenSource()

let t =
    Task.Run<int>(fun () ->
        task {

            do! Task.Delay(TimeSpan.FromSeconds(1.5), source.Token)
            return 42
        })

source.Cancel()

try
    t.Wait()

with :? AggregateException as ae ->
    for e in ae.InnerExceptions do
        printfn $"{e.GetType().Name}: {e.Message}"

printf $"Task t Status: {t.Status}"

if t.Status = TaskStatus.RanToCompletion then
    printf $", Result: {t.Result}"

source.Dispose()

// The example displays output like the following:
//       TaskCanceledException: A task was canceled.
//       Task t Status: Canceled

Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim source As New CancellationTokenSource()
      
      Dim t = Task.Run(Async Function()
                                Await Task.Delay(TimeSpan.FromSeconds(1.5),
                                                 source.Token)
                                Return 42
                       End Function)
      source.Cancel()
      Try
         t.Wait()
      Catch ae As AggregateException
         For Each e In ae.InnerExceptions
            Console.WriteLine("{0}: {1}", e.GetType().Name, e.Message)
         Next
      End Try
      Console.Write("Task t Status: {0}", t.Status)
      If t.Status = TaskStatus.RanToCompletion Then
         Console.Write(", Result: {0}", t.Result)
      End If
      source.Dispose()
   End Sub
End Module
' The example displays output like the following:
'       TaskCanceledException: A task was canceled.
'       Task t Status: Canceled

Note que este exemplo inclui uma condição potencial de corrida: depende da tarefa executar assíncronamente o atraso quando o token é cancelado. Embora o atraso de 1,5 segundos entre a chamada e o Delay(TimeSpan, CancellationToken) método torne essa suposição provável, é ainda assim possível que a chamada para o Delay(TimeSpan, CancellationToken) método possa regressar antes do token ser cancelado. Nesse caso, o exemplo produz o seguinte resultado:

Task t Status: RanToCompletion, Result: 42

Observações

Se o token de cancelamento for sinalizado antes do atraso temporal especificado, resulta uma TaskCanceledException exceção e a tarefa é concluída no Canceled estado. Caso contrário, a tarefa é concluída no RanToCompletion estado assim que o atraso especificado termina.

Para cenários de utilização e exemplos adicionais, consulte a documentação sobre a Delay(Int32) sobrecarga.

Este método depende do relógio do sistema. Isto significa que o atraso temporal será aproximadamente igual à resolução do relógio do sistema se o argumento delay for inferior à resolução do relógio do sistema, que é de aproximadamente 15 milissegundos nos sistemas Windows.

public:
 static System::Threading::Tasks::Task ^ Delay(int millisecondsDelay, System::Threading::CancellationToken cancellationToken);

public static System.Threading.Tasks.Task Delay(int millisecondsDelay, System.Threading.CancellationToken cancellationToken);

static member Delay : int * System.Threading.CancellationToken -> System.Threading.Tasks.Task

Public Shared Function Delay (millisecondsDelay As Integer, cancellationToken As CancellationToken) As Task

Parâmetros

Devoluções

Uma tarefa que representa o atraso temporal.

Exceções

Exemplos

O exemplo seguinte lança uma tarefa que inclui uma chamada ao Delay(Int32, CancellationToken) método com um atraso de um segundo. Antes do intervalo de atraso terminar, o token é cancelado. A saída do exemplo mostra que, como resultado, um TaskCanceledException é lançado, e a propriedade das Status tarefas é definida para Canceled.

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

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

      var t = Task.Run(async delegate
              {
                 await Task.Delay(1000, source.Token);
                 return 42;
              });
      source.Cancel();
      try {
         t.Wait();
      }
      catch (AggregateException ae) {
         foreach (var e in ae.InnerExceptions)
            Console.WriteLine("{0}: {1}", e.GetType().Name, e.Message);
      }
      Console.Write("Task t Status: {0}", t.Status);
      if (t.Status == TaskStatus.RanToCompletion)
         Console.Write(", Result: {0}", t.Result);
      source.Dispose();
   }
}
// The example displays the following output:
//       TaskCanceledException: A task was canceled.
//       Task t Status: Canceled

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

let source = new CancellationTokenSource()

let t =
    Task.Run<int>(fun () ->
        task {
            do! Task.Delay(1000, source.Token)
            return 42
        })

source.Cancel()

try
    t.Wait()

with :? AggregateException as ae ->
    for e in ae.InnerExceptions do
        printfn $"{e.GetType().Name}: {e.Message}"

printf $"Task t Status: {t.Status}"

if t.Status = TaskStatus.RanToCompletion then
    printf $", Result: {t.Result}"

source.Dispose()


// The example displays the following output:
//       TaskCanceledException: A task was canceled.
//       Task t Status: Canceled

Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim source As New CancellationTokenSource()
      
      Dim t = Task.Run(Async Function()
                                Await Task.Delay(1000, source.Token)
                                Return 42
                       End Function)
      source.Cancel()
      Try
         t.Wait()
      Catch ae As AggregateException
         For Each e In ae.InnerExceptions
            Console.WriteLine("{0}: {1}", e.GetType().Name, e.Message)
         Next
      End Try
      Console.Write("Task t Status: {0}", t.Status)
      If t.Status = TaskStatus.RanToCompletion Then
         Console.Write(", Result: {0}", t.Result)
      End If
      source.Dispose()
   End Sub
End Module
' The example displays the following output:
'       TaskCanceledException: A task was canceled.
'       Task t Status: Canceled

Observações

Se o token de cancelamento for sinalizado antes do atraso temporal especificado, resulta uma TaskCanceledException exceção e a tarefa é concluída no Canceled estado. Caso contrário, a tarefa é concluída no RanToCompletion estado assim que o atraso especificado termina.

Para cenários de utilização e exemplos adicionais, consulte a documentação sobre a Delay(Int32) sobrecarga.

Este método depende do relógio do sistema. Isto significa que o atraso temporal será aproximadamente igual à resolução do relógio do sistema se o argumento millisecondsDelay for inferior à resolução do relógio do sistema, que é de aproximadamente 15 milissegundos nos sistemas Windows.

public:
 static System::Threading::Tasks::Task ^ Delay(int millisecondsDelay);

public static System.Threading.Tasks.Task Delay(int millisecondsDelay);

static member Delay : int -> System.Threading.Tasks.Task

Public Shared Function Delay (millisecondsDelay As Integer) As Task

Parâmetros

Devoluções

Uma tarefa que representa o atraso temporal.

Exceções

Exemplos

O exemplo seguinte mostra uma utilização simples do Delay método.

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      var t = Task.Run(async delegate
              {
                 await Task.Delay(1000);
                 return 42;
              });
      t.Wait();
      Console.WriteLine("Task t Status: {0}, Result: {1}",
                        t.Status, t.Result);
   }
}
// The example displays the following output:
//        Task t Status: RanToCompletion, Result: 42

open System.Threading.Tasks

let t =
    Task.Run<int>(fun () ->
        task {
            do! Task.Delay 1000
            return 42
        })

t.Wait()
printfn $"Task t Status: {t.Status}, Result: {t.Result}"

// The example displays the following output:
//        Task t Status: RanToCompletion, Result: 42

Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim t = Task.Run(Async Function()
                                Await Task.Delay(1000)
                                Return 42
                       End Function)
      t.Wait()
      Console.WriteLine("Task t Status: {0}, Result: {1}",
                        t.Status, t.Result)
   End Sub
End Module
' The example displays the following output:
'       Task t Status: RanToCompletion, Result: 42

Observações

O Delay método é tipicamente usado para atrasar a operação total ou parcial de uma tarefa durante um intervalo de tempo especificado. Mais frequentemente, o atraso temporal é introduzido:

• No início da tarefa, como mostra o exemplo seguinte.

  Stopwatch sw = Stopwatch.StartNew();
  var delay = Task.Delay(1000).ContinueWith(_ =>
                             { sw.Stop();
                               return sw.ElapsedMilliseconds; } );
  
  Console.WriteLine("Elapsed milliseconds: {0}", delay.Result);
  // The example displays output like the following:
  //        Elapsed milliseconds: 1013
  

      let sw = Stopwatch.StartNew()
  
      let delay =
          Task
              .Delay(1000)
              .ContinueWith(fun _ ->
                  sw.Stop()
                  sw.ElapsedMilliseconds)
  
      printfn $"Elapsed milliseconds: {delay.Result}"
  // The example displays output like the following:
  //        Elapsed milliseconds: 1013
  

  Dim sw As Stopwatch = Stopwatch.StartNew()
  Dim delay1 = Task.Delay(1000)
  Dim delay2 = delay1.ContinueWith( Function(antecedent)
                          sw.Stop()
                          Return sw.ElapsedMilliseconds
                        End Function)
  
  Console.WriteLine("Elapsed milliseconds: {0}", delay2.Result)
  ' The example displays output like the following:
  '        Elapsed milliseconds: 1013
  

• Em algum momento enquanto a tarefa está a ser executada. Neste caso, a chamada ao Delay método é executada como uma tarefa filha dentro de uma tarefa, como mostra o exemplo seguinte. Note-se que, como a tarefa que chama o Delay método é executada de forma assíncrona, a tarefa pai deve esperar que esta seja concluída usando a await palavra-chave.

  var delay = Task.Run( async () => { Stopwatch sw = Stopwatch.StartNew();
                                      await Task.Delay(2500);
                                      sw.Stop();
                                      return sw.ElapsedMilliseconds; });
  
  Console.WriteLine("Elapsed milliseconds: {0}", delay.Result);
  // The example displays output like the following:
  //        Elapsed milliseconds: 2501
  

      let delay =
          Task.Run<int64>(fun () ->
              task {
                  let sw = Stopwatch.StartNew()
                  do! Task.Delay 2500
                  sw.Stop()
                  return sw.ElapsedMilliseconds
              })
  
      printfn $"Elapsed milliseconds: {delay.Result}"
  // The example displays output like the following:
  //        Elapsed milliseconds: 2501
  

  Dim delay = Task.Run( Async Function()
                           Dim sw As Stopwatch = Stopwatch.StartNew()
                           Await Task.Delay(2500)
                           sw.Stop()
                           Return sw.ElapsedMilliseconds
                        End Function )
  
  Console.WriteLine("Elapsed milliseconds: {0}", delay.Result)
  ' The example displays output like the following:
  '        Elapsed milliseconds: 2501
  

Após o atraso de tempo especificado, a tarefa é concluída no estado RanToCompletion .

Este método depende do relógio do sistema. Isto significa que o atraso temporal será aproximadamente igual à resolução do relógio do sistema se o argumento millisecondsDelay for inferior à resolução do relógio do sistema, que é de aproximadamente 15 milissegundos nos sistemas Windows.

public:
 static System::Threading::Tasks::Task ^ Delay(TimeSpan delay);

public static System.Threading.Tasks.Task Delay(TimeSpan delay);

static member Delay : TimeSpan -> System.Threading.Tasks.Task

Public Shared Function Delay (delay As TimeSpan) As Task

Parâmetros

Devoluções

Uma tarefa que representa o atraso temporal.

Exceções

Exemplos

O exemplo seguinte mostra uma utilização simples do Delay método.

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      var t = Task.Run(async delegate
              {
                 await Task.Delay(TimeSpan.FromSeconds(1.5));
                 return 42;
              });
      t.Wait();
      Console.WriteLine("Task t Status: {0}, Result: {1}",
                        t.Status, t.Result);
   }
}
// The example displays the following output:
//        Task t Status: RanToCompletion, Result: 42

open System
open System.Threading.Tasks

let t =
    Task.Run<int>(fun () ->
        task {
            do! Task.Delay(TimeSpan.FromSeconds 1.5)
            return 42
        })

t.Wait()
printfn $"Task t Status: {t.Status}, Result: {t.Result}"

// The example displays the following output:
//        Task t Status: RanToCompletion, Result: 42

Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim t = Task.Run(Async Function()
                                Await Task.Delay(TimeSpan.FromSeconds(1.5))
                                Return 42
                       End Function)
      t.Wait()
      Console.WriteLine("Task t Status: {0}, Result: {1}",
                        t.Status, t.Result)
   End Sub
End Module
' The example displays the following output:
'       Task t Status: RanToCompletion, Result: 42

Observações

Após o atraso temporal especificado, a tarefa é concluída no RanToCompletion estado.

Para cenários de utilização e exemplos adicionais, consulte a documentação sobre a Delay(Int32) sobrecarga.

Este método depende do relógio do sistema. Isto significa que o atraso temporal será aproximadamente igual à resolução do relógio do sistema se o argumento delay for inferior à resolução do relógio do sistema, que é de aproximadamente 15 milissegundos nos sistemas Windows.