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
- Channels - .NET
- BoundedChannelOptions Class
- BoundedChannelFullMode Enum
- Channel.CreateBounded Method
- ChannelWriter<T>.TryWrite(T) Method
- ChannelWriter<T>.WriteAsync(T, CancellationToken) Method
- ChannelWriter<T>.WaitToWriteAsync(CancellationToken) Method
- ChannelReader<T>.ReadAllAsync(CancellationToken) Method