Task.Delay Método

Referência

Definição

Namespace:: System.Threading.Tasks

Assembly:: System.Runtime.dll

Assembly:: System.Threading.Tasks.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.

Sobrecargas

Delay(TimeSpan, TimeProvider, CancellationToken)	Cria uma tarefa cancelável concluída após um intervalo de tempo especificado.
Delay(TimeSpan, CancellationToken)	Cria uma tarefa cancelável 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)	Cria uma tarefa que é concluída após um intervalo de tempo especificado.
Delay(Int32)	Cria uma tarefa que é concluída após um número especificado de milissegundos.
Delay(Int32, CancellationToken)	Cria uma tarefa cancelável concluída após um número especificado de milissegundos.

Delay(TimeSpan, TimeProvider, CancellationToken)

Origem:: Task.cs

Origem:: Task.cs

Cria uma tarefa cancelável 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 a 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 ao aguardar a conclusão da tarefa.

Retornos

Task

Uma tarefa que representa o atraso.

Exceções

ArgumentOutOfRangeException

delay representa um intervalo de tempo negativo diferente de InfiniteTimeSpan.

- ou -

delayA propriedade de TotalMilliseconds é 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

Delay(TimeSpan, CancellationToken)

Origem:: Task.cs

Origem:: Task.cs

Origem:: Task.cs

Cria uma tarefa cancelável 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 tempo que se deve aguardar antes de concluir a tarefa retornada ou Timeout.InfiniteTimeSpan para aguardar indefinidamente.

cancellationToken: CancellationToken

Um token de cancelamento a ser observado ao aguardar a conclusão da tarefa.

Retornos

Task

Uma tarefa que representa o atraso.

Exceções

ArgumentOutOfRangeException

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

- ou -

A delay propriedade do TotalMilliseconds argumento é 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.

Exemplos

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

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 Delay(TimeSpan, CancellationToken) método torne essa suposição provável, no entanto, é possível que a chamada para o Delay(TimeSpan, CancellationToken) método 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, uma TaskCanceledException exceção resultará e a tarefa será concluída no Canceled estado . Caso contrário, a tarefa será concluída no RanToCompletion estado depois que o atraso de tempo especificado tiver decorrido.

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

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 delay argumento for menor que a resolução do relógio do sistema, que é de aproximadamente 15 milissegundos em sistemas Windows.

Observação

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

Exceções

ArgumentOutOfRangeException

delay representa um intervalo de tempo negativo diferente de InfiniteTimeSpan.

- ou -

delayA propriedade de TotalMilliseconds é maior que 4294967294.

ArgumentNullException

O argumento timeProvider é null.

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 tempo que se deve aguardar antes de concluir a tarefa retornada ou Timeout.InfiniteTimeSpan para aguardar indefinidamente.

Retornos

Task

Uma tarefa que representa o atraso.

Exceções

ArgumentOutOfRangeException

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

- ou -

A delay propriedade do TotalMilliseconds argumento é 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 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

Comentários

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

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

Observação

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)

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 para esperar antes de concluir a tarefa retornada ou -1 para aguardar indefinidamente.

Retornos

Task

Uma tarefa que representa o atraso.

Exceções

ArgumentOutOfRangeException

O argumento millisecondsDelay é menor que -1.

Exemplos

O exemplo a seguir mostra um uso 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

Comentários

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

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 millisecondsDelay argumento for menor que a resolução do relógio do sistema, que é de aproximadamente 15 milissegundos em sistemas Windows.

Observação

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 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 para esperar antes de concluir a tarefa retornada ou -1 para aguardar indefinidamente.

cancellationToken: CancellationToken

Um token de cancelamento a ser observado ao aguardar a conclusão da tarefa.

Retornos

Task

Uma tarefa que representa o atraso.

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.

Exemplos

O exemplo a seguir inicia uma tarefa que inclui uma chamada para o Delay(Int32, CancellationToken) método com um atraso de um segundo. Antes que o intervalo de atraso desaiba, o token é cancelado. A saída do exemplo mostra que, como resultado, um TaskCanceledException é gerado e a propriedade das Status tarefas é definida Canceledcomo .

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

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

Observação

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

Task.Delay Método

Definição

Sobrecargas

Delay(TimeSpan, TimeProvider, CancellationToken)

Parâmetros

Retornos

Exceções

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)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Aplica-se a

Delay(Int32)

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

Comentários

Recursos adicionais