Task.Delay Método

Origem:

Task.cs

Origem:

Task.cs

Origem:

Task.cs

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

Retornos

Uma tarefa que representa o atraso de tempo.

Exceções

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.

Origem:

Task.cs

Origem:

Task.cs

Origem:

Task.cs

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

Retornos

Uma tarefa que representa o atraso de tempo.

Exceções

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.

Origem:

Task.cs

Origem:

Task.cs

Origem:

Task.cs

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

Retornos

Uma tarefa que representa o atraso de tempo.

Exceções

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.

Origem:

Task.cs

Origem:

Task.cs

Origem:

Task.cs

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

Retornos

Uma tarefa que representa o atraso de tempo.

Exceções

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.

Origem:

Task.cs

Origem:

Task.cs

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

Retornos

Uma tarefa que representa o atraso de tempo.

Exceções

Origem:

Task.cs

Origem:

Task.cs

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

Retornos

Uma tarefa que representa o atraso de tempo.

Exceções