Task.Delay Método

Definição

Cria uma tarefa que será concluída após um atraso de tempo.

Sobrecargas

Delay(Int32)

Cria uma tarefa que é concluída após um número especificado de milissegundos.

Delay(TimeSpan)

Cria uma tarefa que é concluída após um intervalo de tempo especificado.

Delay(Int32, CancellationToken)

Cria uma tarefa cancelável que é concluída após um número especificado de milissegundos.

Delay(TimeSpan, CancellationToken)

Cria uma tarefa cancelável que é concluída após um intervalo de tempo especificado.

Delay(TimeSpan, TimeProvider)

Cria uma tarefa que é concluída após um intervalo de tempo especificado.

Delay(TimeSpan, TimeProvider, CancellationToken)

Cria uma tarefa cancelável que é concluída após um intervalo de tempo especificado.

Delay(Int32)

Origem:
Task.cs
Origem:
Task.cs
Origem:
Task.cs

Cria uma tarefa que é concluída após um número especificado de milissegundos.

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

millisecondsDelay
Int32

O número de milissegundos a aguardar antes de concluir a tarefa retornada ou -1 aguardar indefinidamente.

Retornos

Uma tarefa que representa o atraso de tempo.

Exceções

O argumento millisecondsDelay é menor que -1.

Exemplos

O exemplo a seguir mostra um uso simples do método Delay.

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

Comentários

O método Delay normalmente é usado para atrasar a operação de toda ou parte de uma tarefa para um intervalo de tempo especificado. Mais comumente, o atraso de tempo é introduzido:

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

    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á sendo executada. Nesse caso, a chamada para o método Delay é executada como uma tarefa filho dentro de uma tarefa, como mostra o exemplo a seguir. Observe que, como a tarefa que chama o método Delay é executada de forma assíncrona, a tarefa pai deve aguardar a conclusão usando a palavra-chave await.

    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.

Esse método depende do relógio do sistema. Isso significa que o atraso de tempo será aproximadamente igual à resolução do relógio do sistema se o argumento millisecondsDelay for menor que a resolução do relógio do sistema, que é aproximadamente 15 milissegundos em sistemas Windows.

Nota

O relógio do sistema usado é o mesmo relógio usado por GetTickCount, que não é afetado por alterações feitas com timeBeginPeriod e timeEndPeriod.

Aplica-se a

Delay(TimeSpan)

Origem:
Task.cs
Origem:
Task.cs
Origem:
Task.cs

Cria uma tarefa que é concluída após um intervalo de tempo especificado.

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

delay
TimeSpan

O período de tempo a aguardar antes de concluir a tarefa retornada ou Timeout.InfiniteTimeSpan aguardar indefinidamente.

Retornos

Uma tarefa que representa o atraso de tempo.

Exceções

delay representa um intervalo de tempo negativo diferente de Timeout.InfiniteTimeSpan.

-ou-

A propriedade TotalMilliseconds do argumento delay é maior que 4294967294 no .NET 6 e versões posteriores ou Int32.MaxValue em todas as versões anteriores.

Exemplos

O exemplo a seguir mostra um uso simples do método Delay.

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

Comentários

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

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

Esse método depende do relógio do sistema. Isso significa que o atraso de tempo será aproximadamente igual à resolução do relógio do sistema se o argumento delay for menor que a resolução do relógio do sistema, que é aproximadamente 15 milissegundos em sistemas Windows.

Nota

O relógio do sistema usado é o mesmo relógio usado por GetTickCount, que não é afetado por alterações feitas com timeBeginPeriod e timeEndPeriod.

Aplica-se a

Delay(Int32, CancellationToken)

Origem:
Task.cs
Origem:
Task.cs
Origem:
Task.cs

Cria uma tarefa cancelável que é concluída após um número especificado de milissegundos.

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

millisecondsDelay
Int32

O número de milissegundos a aguardar antes de concluir a tarefa retornada ou -1 aguardar indefinidamente.

cancellationToken
CancellationToken

Um token de cancelamento a ser observado enquanto aguarda a conclusão da tarefa.

Retornos

Uma tarefa que representa o atraso de tempo.

Exceções

O argumento millisecondsDelay é menor que -1.

A tarefa foi cancelada. Essa exceção é armazenada na tarefa retornada.

O cancellationToken fornecido já foi descartado.

A tarefa foi cancelada.

Exemplos

O exemplo a seguir inicia uma tarefa que inclui uma chamada para o método Delay(Int32, CancellationToken) com um atraso de um segundo. Antes que o intervalo de atraso se esvaia, o token é cancelado. A saída do exemplo mostra que, como resultado, um TaskCanceledException é gerado e a propriedade Status das tarefas é definida como 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

Comentários

Se o token de cancelamento for sinalizado antes do atraso de tempo especificado, um TaskCanceledException resultados de exceção e a tarefa for concluída no estado Canceled. Caso contrário, a tarefa será concluída no estado RanToCompletion depois que o atraso de tempo especificado tiver decorrido.

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

Esse método depende do relógio do sistema. Isso significa que o atraso de tempo será aproximadamente igual à resolução do relógio do sistema se o argumento millisecondsDelay for menor que a resolução do relógio do sistema, que é aproximadamente 15 milissegundos em sistemas Windows.

Nota

O relógio do sistema usado é o mesmo relógio usado por GetTickCount, que não é afetado por alterações feitas com timeBeginPeriod e timeEndPeriod.

Aplica-se a

Delay(TimeSpan, CancellationToken)

Origem:
Task.cs
Origem:
Task.cs
Origem:
Task.cs

Cria uma tarefa cancelável que é concluída após um intervalo de tempo especificado.

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

delay
TimeSpan

O período de tempo a aguardar antes de concluir a tarefa retornada ou Timeout.InfiniteTimeSpan aguardar indefinidamente.

cancellationToken
CancellationToken

Um token de cancelamento a ser observado enquanto aguarda a conclusão da tarefa.

Retornos

Uma tarefa que representa o atraso de tempo.

Exceções

delay representa um intervalo de tempo negativo diferente de Timeout.InfiniteTimeSpan.

-ou-

A propriedade TotalMilliseconds do argumento delay é maior que 4294967294 no .NET 6 e versões posteriores ou Int32.MaxValue em todas as versões anteriores.

A tarefa foi cancelada. Essa exceção é armazenada na tarefa retornada.

O cancellationToken fornecido já foi descartado.

A tarefa foi cancelada.

Exemplos

O exemplo a seguir inicia uma tarefa que inclui uma chamada para o método Delay(TimeSpan, CancellationToken) com um atraso de 1,5 segundo. Antes que o intervalo de atraso se esvaia, o token é cancelado. A saída do exemplo mostra que, como resultado, um TaskCanceledException é gerado e a propriedade Status das tarefas é definida como 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

Observe que este exemplo inclui uma condição de corrida em potencial: depende da tarefa executar de forma assíncrona o atraso quando o token é cancelado. Embora o atraso de 1,5 segundo da chamada para o método Delay(TimeSpan, CancellationToken) torne essa suposição provável, no entanto, é possível que a chamada para o método Delay(TimeSpan, CancellationToken) possa retornar antes que o token seja cancelado. Nesse caso, o exemplo produz a seguinte saída:

Task t Status: RanToCompletion, Result: 42

Comentários

Se o token de cancelamento for sinalizado antes do atraso de tempo especificado, um TaskCanceledException resultados de exceção e a tarefa for concluída no estado Canceled. Caso contrário, a tarefa será concluída no estado RanToCompletion depois que o atraso de tempo especificado tiver decorrido.

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

Esse método depende do relógio do sistema. Isso significa que o atraso de tempo será aproximadamente igual à resolução do relógio do sistema se o argumento delay for menor que a resolução do relógio do sistema, que é aproximadamente 15 milissegundos em sistemas Windows.

Nota

O relógio do sistema usado é o mesmo relógio usado por GetTickCount, que não é afetado por alterações feitas com timeBeginPeriod e timeEndPeriod.

Aplica-se a

Delay(TimeSpan, TimeProvider)

Origem:
Task.cs
Origem:
Task.cs

Cria uma tarefa que é concluída após um intervalo de tempo especificado.

public:
 static System::Threading::Tasks::Task ^ Delay(TimeSpan delay, TimeProvider ^ timeProvider);
public static System.Threading.Tasks.Task Delay (TimeSpan delay, TimeProvider timeProvider);
static member Delay : TimeSpan * TimeProvider -> System.Threading.Tasks.Task
Public Shared Function Delay (delay As TimeSpan, timeProvider As TimeProvider) As Task

Parâmetros

delay
TimeSpan

O TimeSpan aguardar antes de concluir a tarefa retornada ou InfiniteTimeSpan aguardar indefinidamente.

timeProvider
TimeProvider

O TimeProvider com o qual interpretar delay.

Retornos

Uma tarefa que representa o atraso de tempo.

Exceções

delay representa um intervalo de tempo negativo diferente de InfiniteTimeSpan.

-ou-

A propriedade TotalMilliseconds de delayé maior que 4294967294.

O argumento timeProvider é null.

Aplica-se a

Delay(TimeSpan, TimeProvider, CancellationToken)

Origem:
Task.cs
Origem:
Task.cs

Cria uma tarefa cancelável que é concluída após um intervalo de tempo especificado.

public:
 static System::Threading::Tasks::Task ^ Delay(TimeSpan delay, TimeProvider ^ timeProvider, System::Threading::CancellationToken cancellationToken);
public static System.Threading.Tasks.Task Delay (TimeSpan delay, TimeProvider timeProvider, System.Threading.CancellationToken cancellationToken);
static member Delay : TimeSpan * TimeProvider * System.Threading.CancellationToken -> System.Threading.Tasks.Task
Public Shared Function Delay (delay As TimeSpan, timeProvider As TimeProvider, cancellationToken As CancellationToken) As Task

Parâmetros

delay
TimeSpan

O TimeSpan aguardar antes de concluir a tarefa retornada ou InfiniteTimeSpan aguardar indefinidamente.

timeProvider
TimeProvider

O TimeProvider com o qual interpretar delay.

cancellationToken
CancellationToken

Um token de cancelamento a ser observado enquanto aguarda a conclusão da tarefa.

Retornos

Uma tarefa que representa o atraso de tempo.

Exceções

delay representa um intervalo de tempo negativo diferente de InfiniteTimeSpan.

-ou-

A propriedade TotalMilliseconds de delayé maior que 4294967294.

O argumento timeProvider é null.

O token de cancelamento foi cancelado. Essa exceção é armazenada na tarefa retornada.

Aplica-se a