Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C#

BoundedChannelOptions e BoundedChannelFullMode.Wait

Defina o limite do buffer e veja por que razão, com o canal cheio, `TryWrite` devolve logo `false`, enquanto `WriteAsync` aguarda espaço de forma assíncrona.

Versão: C# 12 and .NET 8; later runtimes may add compatible features

Sintaxe

using System.Threading.Channels;

var options = new BoundedChannelOptions(capacity: 2)
{
    FullMode = BoundedChannelFullMode.Wait
};
Channel<int> channel = Channel.CreateBounded<int>(options);
bool written = channel.Writer.TryWrite(1);
await channel.Writer.WriteAsync(2);

Em C# 12 e .NET 8, passe BoundedChannelOptions do espaço de nomes System.Threading.Channels a Channel.CreateBounded<T>(options). Uma Capacity positiva limita o número de elementos no buffer, não os que os consumidores já estão a processar nem as escritas pendentes. A sobrecarga mais simples Channel.CreateBounded<T>(capacity) também usa Wait.

FullMode determina o que acontece quando se tenta escrever com o buffer cheio. O modo predefinido, BoundedChannelFullMode.Wait, não descarta elementos para lidar com a saturação. TryWrite(item) devolve true se a escrita for bem-sucedida, ou false imediatamente se o canal estiver cheio ou fechado para escritas. Um resultado false não deixa nenhuma escrita pendente.

WriteAsync(item, cancellationToken) devolve um ValueTask: pode concluir de imediato, mas se o buffer estiver cheio, aguarda espaço sem bloquear uma thread. Use await antes de produzir o elemento seguinte para que um consumidor lento possa abrandar o produtor (contrapressão). O cancelamento pode interromper uma escrita pendente com OperationCanceledException, e o fecho normal da escrita com ChannelClosedException. O sucesso indica que o elemento foi aceite, não que tenha sido processado.

WaitToWriteAsync indica que é possível escrever, mas não reserva espaço. Com vários produtores, outro pode ocupá-lo; se TryWrite falhar, volte a aguardar se ainda for possível escrever. Após o fecho normal com Complete(), o consumidor ainda pode ler os elementos do buffer.

Exemplos

using System;
using System.Threading.Channels;

var channel = Channel.CreateBounded<int>(new BoundedChannelOptions(capacity: 1)
{
    FullMode = BoundedChannelFullMode.Wait
});

await channel.Writer.WriteAsync(1);
Console.WriteLine($"TryWrite(99): {channel.Writer.TryWrite(99)}");

var pending = channel.Writer.WriteAsync(2);
Console.WriteLine($"WriteAsync(2) completed: {pending.IsCompleted}");

Console.WriteLine($"Read: {await channel.Reader.ReadAsync()}");
await pending;
channel.Writer.Complete();

await foreach (var item in channel.Reader.ReadAllAsync())
{
    Console.WriteLine($"Read: {item}");
}

Resultado

TryWrite(99): False
WriteAsync(2) completed: False
Read: 1
Read: 2

`1` enche o buffer. A tentativa de escrever `99` falha e a escrita de `2` fica pendente. Ler `1` liberta espaço, a escrita de `2` termina e `ReadAllAsync()` lê `2` após `Complete()`.

Lições relacionadas

  • C# · Lição 46 · Avançado · Versão: 3

Fontes