> For the complete documentation index, see [llms.txt](https://docs.skail.dev/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.skail.dev/construir/sdk-.net/delay.md).

# Delay

Espera durável por um intervalo de tempo. A execução hiberna sem ocupar thread nem processo e é retomada quando o prazo vence, mesmo que a aplicação tenha sido reiniciada no meio.

## Assinaturas

```csharp
public static SkailTask Delay(TimeSpan delay);
public static SkailTask DelaySeconds(ulong seconds);
public static SkailTask DelayMinutes(ulong minutes);
```

| Método                | Parâmetro                               | Uso                                                                             |
| --------------------- | --------------------------------------- | ------------------------------------------------------------------------------- |
| `Delay(TimeSpan)`     | Qualquer intervalo, inclusive calculado | Forma geral; use para horas, dias, semanas e para intervalos derivados de datas |
| `DelaySeconds(ulong)` | Segundos                                | Atalho                                                                          |
| `DelayMinutes(ulong)` | Minutos                                 | Atalho                                                                          |

Só dentro de `[SkailFunction]`. Dentro de `[SkailCommand]`, use `Task.Delay` normalmente.

## Comportamento

O runtime registra o passo com o prazo, pede ao skail para acordar a execução naquele momento e hiberna a execução. No prazo, a execução é reentregue; o runtime reexecuta a function, encontra o delay concluído e segue para o próximo `await`. Funciona para segundos e para semanas com o mesmo custo enquanto espera: nenhum.

Se a aplicação estiver fora do ar quando o prazo vencer, a retomada acontece quando ela voltar; o delay não se perde. Se o código publicado mudou de forma que a sequência de `await`s da function é outra, a retomada lança `SkailNonDeterministicException`.

Um `Delay` criado sem `await` e passado a `WhenAny` funciona como prazo de uma espera; é o uso mais comum. Um `Delay` com intervalo zero ou negativo conclui imediatamente.

## Exemplo

```csharp
[SkailFunction]
public async SkailTask ProcessarReembolso(Guid pedidoId)
{
    await RegistrarSolicitacao(pedidoId);
    await SkailTask.DelayMinutes(30);                                 // aguarda 30 minutos, hibernado
    await ExecutarEstorno(pedidoId);
}
```

Intervalo calculado a partir de uma data. O relógio vem de um command, porque `DateTime.UtcNow` na function quebra o replay:

```csharp
[SkailFunction]
public async SkailTask EnviarLembrete(Assinatura assinatura)
{
    var agora = await ObterDataAtual();
    var ateOLembrete = assinatura.Vencimento.AddDays(-3) - agora;
    if (ateOLembrete > TimeSpan.Zero)
        await SkailTask.Delay(ateOLembrete);
    await NotificarUsuario(assinatura.UsuarioId);
}

[SkailCommand]
public async SkailTask<DateTime> ObterDataAtual() => await Task.FromResult(DateTime.UtcNow);
```

Como prazo de uma espera:

```csharp
var evento = SkailTask.WaitForEvent<Aprovacao>(Eventos.Aprovado, id.ToString());
var prazo  = SkailTask.Delay(TimeSpan.FromHours(24));
if (await SkailTask.WhenAny(evento, prazo) == prazo) { /* timeout */ }
```

## Observabilidade

No Monitor, um `Delay` aparece na linha do tempo com o momento em que a execução deve ser retomada, e a execução fica no estado de aguardando prazo. Isso distingue uma execução que está esperando o tempo passar de uma que está presa por outro motivo.

## Erros relacionados

| Erro                                         | Causa                                                                                                       |
| -------------------------------------------- | ----------------------------------------------------------------------------------------------------------- |
| `SkailNonDeterministicException` na retomada | Intervalo calculado com `DateTime.UtcNow` na function, ou `Task.Delay` no lugar de `SkailTask.Delay`        |
| Delay não acorda                             | Nenhuma instância da aplicação rodando com esse workload; ver [Troubleshooting](/operar/troubleshooting.md) |

## Veja também

[Tempo e agendamento](/aprender/fundamentos/tempo-e-agendamento.md), [Como esperar com timeout](/construir/escrever-fluxos/como-esperar-com-timeout.md), [Timeout e prazo](/construir/padroes-e-antipadroes/timeout-e-prazo.md), [WhenAll e WhenAny](/construir/sdk-.net/whenall-e-whenany.md).