Task.Delay Método

Referência

Definição

Namespace:: System.Threading.Tasks

Assembly:: System.Threading.Tasks.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

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

Task

Uma tarefa que representa o atraso de tempo.

Exceções

ArgumentOutOfRangeException

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

Task

Uma tarefa que representa o atraso de tempo.

Exceções

ArgumentOutOfRangeException

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

Task

Uma tarefa que representa o atraso de tempo.

Exceções

ArgumentOutOfRangeException

O argumento millisecondsDelay é menor que -1.

OperationCanceledException

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

ObjectDisposedException

O cancellationToken fornecido já foi descartado.

TaskCanceledException

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

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

Task

Uma tarefa que representa o atraso de tempo.

Exceções

ArgumentOutOfRangeException

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.

OperationCanceledException

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

ObjectDisposedException

O cancellationToken fornecido já foi descartado.

TaskCanceledException

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

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

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

Task

Uma tarefa que representa o atraso de tempo.

Exceções

ArgumentOutOfRangeException

delay representa um intervalo de tempo negativo diferente de InfiniteTimeSpan.

-ou-

A propriedade TotalMilliseconds de delayé maior que 4294967294.

ArgumentNullException

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

Task

Uma tarefa que representa o atraso de tempo.

Exceções

ArgumentOutOfRangeException

delay representa um intervalo de tempo negativo diferente de InfiniteTimeSpan.

-ou-

A propriedade TotalMilliseconds de delayé maior que 4294967294.

ArgumentNullException

O argumento timeProvider é null.

OperationCanceledException

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

Aplica-se a

Compartilhar via

Task.Delay Método

Definição

Sobrecargas

Delay(Int32)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Aplica-se a

Delay(TimeSpan)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Aplica-se a

Delay(Int32, CancellationToken)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Aplica-se a

Delay(TimeSpan, CancellationToken)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Aplica-se a

Delay(TimeSpan, TimeProvider)

Parâmetros

Retornos

Exceções

Aplica-se a

Delay(TimeSpan, TimeProvider, CancellationToken)

Parâmetros

Retornos

Exceções

Aplica-se a

Recursos adicionais