C# Academy · Aula

Políticas de tempo limite e alternativa

Limite as esperas e forneça alternativas elegantes.

Políticas de tempo limite e alternativa é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C# Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C# Academy inclui 4 aulas no total.

Por que os Tempos Limite são Importantes

Uma chamada que nunca retorna é pior do que uma que falha: ela mantém linhas de execução e conexões ocupadas. Uma estratégia de tempo limite define por quanto tempo uma operação pode ser executada antes que o Polly a cancele.

Adicionar um Tempo Limite

O Polly v8 fornece AddTimeout. Quando o limite é excedido, ele lança uma TimeoutRejectedException e cancela o token subjacente.

using Polly.Timeout;

var pipeline = new ResiliencePipelineBuilder()
    .AddTimeout(TimeSpan.FromSeconds(3))
    .Build();

Cancelamento Cooperativo

O tempo limite funciona cancelando o CancellationToken passado ao seu retorno de chamada. Seu código deve respeitar esse token para que o tempo limite tenha efeito prontamente.

await pipeline.ExecuteAsync(async token =>
{
    // token is cancelled when the timeout fires
    await httpClient.GetAsync(url, token);
});

Reagir a Tempos Limite

Use TimeoutStrategyOptions com um retorno de chamada OnTimeout para registrar o evento ou gerar métricas quando uma operação for interrompida.

new TimeoutStrategyOptions
{
    Timeout = TimeSpan.FromSeconds(3),
    OnTimeout = args =>
    {
        Console.WriteLine($"Timed out after {args.Timeout}");
        return default;
    }
};

O que é uma Alternativa?

Uma alternativa fornece um resultado substituto quando uma operação falha, para que o usuário tenha uma experiência degradada de forma controlada em vez de receber um erro: dados armazenados em cache, um valor padrão ou uma mensagem amigável.

Adicionar uma Estratégia de Alternativa

AddFallback precisa de um fluxo tipado. Você define quais falhas devem ser tratadas e qual valor deve ser retornado em seu lugar.

using Polly.Fallback;

var pipeline = new ResiliencePipelineBuilder<string>()
    .AddFallback(new FallbackStrategyOptions<string>
    {
        ShouldHandle = new PredicateBuilder<string>()
            .Handle<HttpRequestException>(),
        FallbackAction = args =>
            Outcome.FromResultAsValueTask("cached default")
    })
    .Build();

Retornar Dados Armazenados em Cache como Alternativa

Um padrão comum é fornecer o último valor conhecido como válido a partir do cache quando a chamada em tempo real falha, mantendo o aplicativo responsivo.

FallbackAction = args =>
{
    var cached = _cache.GetLastKnownGood();
    return Outcome.FromResultAsValueTask(cached);
}

Observar Alternativas

O retorno de chamada OnFallback é acionado quando a alternativa é executada, sendo ideal para registrar que um caminho degradado foi seguido.

new FallbackStrategyOptions<string>
{
    FallbackAction = args => Outcome.FromResultAsValueTask("default"),
    OnFallback = args =>
    {
        Console.WriteLine("Fallback executed");
        return default;
    }
};

Tempo Limite e Alternativa Juntos

Combiná-los é poderoso: um tempo limite limita a espera, e uma alternativa fornece um valor quando o tempo limite (ou qualquer falha tratada) ocorre, para que as chamadas nunca fiquem bloqueadas nem causem uma falha.

Escolher Tempos Limite Sensatos

Defina os tempos limite com base em uma latência realista mais uma margem de segurança, não em valores arbitrariamente pequenos. Se for restritivo demais, você fará chamadas saudáveis falharem; se for permissivo demais, perderá o propósito.

A Alternativa é o Último Recurso

Coloque a alternativa como a estratégia mais externa para que ela possa capturar igualmente as falhas de novas tentativas, disjuntores e tempos limite, garantindo que a chamada sempre receba um resultado utilizável.

Verificação Rápida

Teste as estratégias de tempo limite e alternativa.

Recapitulação

Os tempos limite limitam a duração das operações com AddTimeout, cancelando o token e lançando TimeoutRejectedException (respeite o token!). As alternativas fornecem resultados substitutos por meio de AddFallback com uma FallbackAction, geralmente fornecendo dados armazenados em cache. Juntos, eles mantêm os aplicativos responsivos: limitam a espera e depois oferecem uma degradação controlada. Coloque a alternativa na camada mais externa para que ela capture todas as falhas tratadas.

Perguntas Frequentes

A aula “Políticas de tempo limite e alternativa” é grátis?

Sim — o texto completo de “Políticas de tempo limite e alternativa” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C# Academy, atualize para CoddyKit PRO. O curso de C# Academy inclui 4 aulas no total.

O que vou aprender em “Políticas de tempo limite e alternativa”?

Limite as esperas e forneça alternativas elegantes. Você pratica C# Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C# Academy?

Nenhuma experiência prévia é necessária. C# Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Políticas de tempo limite e alternativa”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C# Academy?

Sim. Cada aula de C# Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para C# Academy