> 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/funcionalidades/sdk/whenany.md).

# WhenAny

Às vezes sua lógica precisa disparar mais de uma operação ao mesmo tempo e continuar assim que **a primeira delas terminar** — sem esperar pelas demais. É o caso de um timeout customizado, de uma corrida entre dois provedores, ou de qualquer situação em que o resultado mais rápido é o suficiente.

Para isso você usa `SkailTask.WhenAny`. 

```csharp
[SkailFunction]
public async SkailTask EmitirDocumento(Guid documentoId)
{
    var consultarEmitente = ConsultarEmitente(Guid.NewGuid());
    var gerarDocumento = GerarDocumento(documentoId);

    var primeiroAConcluir = await SkailTask.WhenAny(consultarEmitente, gerarDocumento);

    await BuscarDocumento(documentoId);
    await EnviarWebhook(documentoId);
}
```

As duas operações são disparadas ao mesmo tempo. Assim que a primeira conclui, a execução continua — o retorno é a própria `SkailTask` vencedora, e você pode usar comparação de referência para saber qual foi:

```csharp
var tsk1 = ConsultarEmitente(Guid.NewGuid());
var tsk2 = GerarDocumento(documentoId);

var primeira = await SkailTask.WhenAny(tsk1, tsk2);

if (primeira == tsk1)
{
    // ConsultarEmitente terminou primeiro
}
```

#### Combinando com Delay para timeout

Um padrão comum é usar `SkailTask.WhenAny` junto com um `Delay` para implementar um timeout: se a operação não terminar dentro de um prazo, você segue em frente de qualquer forma.

```csharp
var operacao = ProcessarPagamento(pedidoId);
var timeout = SkailTask.DelaySeconds(30);

var resultado = await SkailTask.WhenAny(operacao, timeout);

if (resultado == timeout)
{
    await NotificarFalhaDeTimeout(pedidoId);
    return;
}

await ConfirmarPedido(pedidoId);
```

#### O que acontece com as tarefas que não venceram

As demais continuam executando normalmente em paralelo. O runtime simplesmente ignora as respostas que chegarem depois que a primeira já concluiu. Nenhuma tarefa é cancelada.

#### Observabilidade

Cada operação disparada dentro do `WhenAny` gera seu próprio item no [portal do skail](https://app.skailhq.com/). No **Monitor**, você consegue ver quais tarefas foram disparadas em paralelo e quanto tempo cada uma levou para concluir.