Pipelines de Dataflow: TPL Dataflow e Rx
Objective
Channel<T> e Parallel.ForEachAsync cobrem a maior parte do trabalho produtor/consumidor, mas duas bibliotecas mais
antigas ainda aparecem em código real: o TPL Dataflow (blocos ligados em pipeline, buffers limitados, estilo pull) e o
Rx.NET (IObservable<T>, estilo push, feito para fluxos de eventos). Este conceito monta um pipeline em Dataflow,
mostra onde o Rx difere (fontes cold e hot, schedulers, a assinatura que nunca é descartada, falta de backpressure),
cobre o Task.WhenEach e a mudança do LINQ assíncrono no .NET 10, e termina com um mesmo trabalho rodando em
Channel<T>, Dataflow, Rx e Parallel.ForEachAsync, medindo vazão e memória. Bases: Channels,
Parallel.ForEachAsync,
IAsyncEnumerable. Tudo em macOS arm64 (14 núcleos).
Versões: .NET SDK 10.0.100, TFM net10.0. System.Threading.Tasks.Dataflow 10.0.0.0 vindo do shared framework (sem
pacote, veja abaixo), System.Reactive 7.0.0, System.Linq.Async 7.0.1 (só para as pontes do Rx).
Use Cases
- Um pipeline em processo com paralelismo e buffer próprios por estágio (parse, enriquecer, agrupar, gravar).
- Agrupar por quantidade antes de um insert em lote; eventos com operadores de tempo (debounce, buffer, combine latest).
- Consumir os resultados conforme cada tarefa termina, com
Task.WhenEach.
Deep Dive
O Dataflow vem no framework
No net10.0 ele não é um pacote. Referenciar System.Threading.Tasks.Dataflow 10.0.15 gerou o aviso NU1510 ("will
not be pruned ... likely unnecessary") e o assembly carregado em tempo de execução veio de
Microsoft.NETCore.App/10.0.0. A documentação diz que ele está incluído no .NET 6 e posteriores; o pacote serve para
.NET Framework e .NET Standard.
Um pipeline: produtor, transformação paralela, consumidor
csharpvar buffer = new BufferBlock<int>(new DataflowBlockOptions { BoundedCapacity = 4 });
var transform = new TransformBlock<int, int>(
async i => { await Task.Delay(i % 5 == 0 ? 40 : 5); return i * i; }, // todo 5o item é lento
new ExecutionDataflowBlockOptions
{ MaxDegreeOfParallelism = 4, BoundedCapacity = 4, EnsureOrdered = ordered });
var sink = new ActionBlock<int>(async v => { arrivals.Add(v); await Task.Delay(5); },
new ExecutionDataflowBlockOptions { BoundedCapacity = 4 });
var link = new DataflowLinkOptions { PropagateCompletion = true };
buffer.LinkTo(transform, link); transform.LinkTo(sink, link);
for (int i = 0; i < 40; i++) await buffer.SendAsync(i);
buffer.Complete(); await sink.Completion;textEnsureOrdered=True: 371 ms, max concurrent transforms 4, produced-but-not-consumed peak 11, arrivals 0,1,2,3,4,5,... EnsureOrdered=False: 250 ms, max concurrent transforms 4, produced-but-not-consumed peak 10, arrivals 1,3,2,4,6,8,...
Três execuções concordaram em até 5 ms. Por padrão a saída mantém a ordem da entrada, então um item lento segura os rápidos atrás dele (371 ms contra 250 ms, e o item 0 chegou em décimo). Desligue a ordenação só se a ordem não importar.
BoundedCapacity é o backpressure
BoundedCapacity limita o que um bloco guarda (na fila, em processamento e a saída pronta esperando o próximo bloco).
Com 4 em cada um dos três blocos, o produtor nunca ficou mais de 11 itens à frente. Com o bloco cheio, Post e
SendAsync diferem:
textPost into BoundedCapacity=3 with a slow consumer: accepted 3, rejected 7 SendAsync of 10 items: producer was held for 362 ms (waited for room) Default (unbounded) block: Post x1000 all accepted, InputCount right after = 1000
Post devolve false e o item se perde se você não conferir; SendAsync espera por espaço. O padrão é ilimitado
(a mesma armadilha de um channel ilimitado).
Conclusão, falhas e cancelamento
PropagateCompletion = true repassa conclusão, falha e cancelamento ao próximo bloco; sem ele o bloco seguinte nunca
termina.
texta fault chain: AggregateException -> AggregateException -> InvalidOperationException no PropagateCompletion: t2 RanToCompletion; a2 completed within 500 ms? False ActionBlock faulted on item 2: handled 2 of 10, status Faulted try/catch inside delegate: ok 6, failed 4, status RanToCompletion cancel: t5 Canceled, a5 Canceled, transformed 10 of 100, input left 0
Uma exceção que escapa do delegate falha o bloco de vez: os itens na fila (8 de 10) são descartados e só o
Completion avisa; depois disso o Post devolve false. Cada repasse embrulha a exceção em mais um
AggregateException, então use Flatten() ou GetBaseException(). Para continuar depois de um item ruim, capture
dentro do delegate. No cancelamento, passe o token nas opções de todos os blocos; o que está em andamento termina e a
fila é descartada.
Os outros blocos
textafter TriggerBatch: [1,2,3,4,5] [6,7,8,9,10] [11,12] (12 posted, batch size 5) BroadcastBlock, 20 messages: fast target got 20, slow target (30 ms per item) got 5: 0,5,10,15,19; late target got: c
BatchBlock<T>(5)emite arrays de 5; a sobra esperaTriggerBatch()ouComplete()(use um timer se não puder esperar).BroadcastBlock<T>oferece cada mensagem a todos os destinos mas guarda só a última: o destino lento viu 5 de 20 e um assinante tardio recebeu sóc: é um bloco de "valor atual", não uma fila de fan-out.BatchBlocknão guloso,JoinBlock,TransformManyBlock: só na documentação.
Rx: push, e cold ou hot decide quem roda o produtor
textcold: 2 subscribers, producer ran 2 times Publish().RefCount(): producer ticks 5; A saw [0,1,2,3,4], late B saw [2,3,4] hot Subject: early [1,2,3], late [3]
Um observable cold (Observable.Create, Interval, Range) inicia o produtor por assinante. Um hot (Subject<T>)
existe por conta própria e quem assina tarde perde os valores anteriores. Publish().RefCount() compartilha uma fonte
cold; ReplaySubject(2) reenvia os dois últimos (o assinante tardio recebeu [2,3]).
Operadores e schedulers do Rx
textThrottle(60ms) over a,b,c (15 ms apart), d, e,f: emitted c@90 d@230 f@370 CombineLatest(1,2 | x | 3 | y): 2x 3x 3y main: thread 1; Range subscriber ran on thread 1 (synchronous); Interval tick on thread 5 (pool)
Throttle é um debounce: emite o último valor depois de um período de silêncio (c, d, f), não limita taxa.
CombineLatest espera os dois lados, então o 1 nunca aparece. Range roda síncrono na thread que assina,
Interval em uma thread do pool; ObserveOn move os callbacks e SubscribeOn move a assinatura, por isso um app de
UI coloca ObserveOn com o scheduler da UI logo antes de tocar num controle. O TestScheduler (Microsoft.Reactive.Testing) é só documentação.
A assinatura que nunca é descartada
Observable.Interval(10 ms).Subscribe(_ => widget.Ticks++), depois as referências à assinatura e ao widget são
largadas e o GC.Collect() roda três vezes:
textsubscription dropped without Dispose: after GC the widget is STILL ALIVE (rooted by the timer), ticks 10 then 21 subscription disposed: ticks at 100 ms = 0; after GC the widget is collected 100000 short-lived subscribers, never disposed: retained 59345 KB, 100 x OnNext took 47 ms 100000 short-lived subscribers, disposed: retained 8 KB, 100 x OnNext took 0 ms
Quem segura o callback e o que ele captura é o timer do scheduler, não a sua variável. Em um Subject de vida longa
(ou um evento embrulhado com FromEventPattern) cada assinatura esquecida também continua na lista de observadores.
Descarte no Dispose, guarde as assinaturas em um CompositeDisposable, ou encerre o fluxo com TakeUntil(stop).
O Rx não tem backpressure, o IAsyncEnumerable puxa
Um produtor rápido de 200.000 itens, o mesmo consumidor lento, contando os itens produzidos e ainda não consumidos:
textRx Range(200000).ObserveOn(slow consumer): max items waiting = 199455 IAsyncEnumerable pull, same slow consumer: max items waiting = 0 Channel.CreateBounded(100), same slow consumer: max items waiting = 100
O ObserveOn separa os lados com uma fila ilimitada, então o push nunca desacelera o produtor. O await foreach só
produz quando pedem, e um channel limitado bloqueia o produtor no limite escolhido. O Rx serve para fontes que você
não consegue pausar (cliques, sensores); o pull serve para uma fonte sua que pode ultrapassar o consumidor. As pontes
(ToAsyncEnumerable(), ToObservable()) não estão no System.Reactive 7.0.0: não compilaram até o
System.Linq.Async 7.0.1 ser referenciado.
Task.WhenEach (.NET 9)
await foreach (var t in Task.WhenEach(tasks)) entrega cada tarefa assim que ela termina:
textWhenEach yielded the 50 ms task at 50 ms (then 100, 200, 300 ms) task faulted: bad one (enumeration kept going) n= 10000: WhenEach 20 ms 4 MB allocated | WhenAny loop 268 ms 404 MB allocated n= 40000: WhenEach 53 ms 20 MB allocated | WhenAny loop 4410 ms 6139 MB allocated
As tarefas voltam na ordem de conclusão, e uma tarefa com falha é entregue, não lançada: a exceção aparece
no await t e o laço continua. O padrão antigo chama WhenAny e remove a concluída a cada volta, o que é quadrático (mesmas somas).
O .NET 10 traz LINQ assíncrono
O System.Linq.AsyncEnumerable.dll está no shared framework do .NET 10: Where, Select e ToListAsync em
IAsyncEnumerable<T> não precisam de pacote (uso em Async Streams).
Um projeto que ainda referencia o pacote antigo, mesmo código (Where, Select, ToListAsync, SelectAwait):
textSystem.Linq.Async 6.0.1 and 6.0.3: error CS0121 (ambiguous call) on Where and ToListAsync System.Linq.Async 7.0.1: builds; SelectAwait warns CS0618 ("Use Select ... additional CancellationToken argument")
Atualize para 7.0.0 ou superior (como diz a página de breaking changes do .NET 10) ou remova a referência; os callbacks
do SelectAwait viram Select com CancellationToken.
Escolhendo, com um trabalho medido
Um trabalho, quatro implementações, cada uma em seu próprio processo, 5 execuções, medianas (faixa entre parênteses).
Os itens são produzidos rápido e carregam uma carga (1 KB na CPU, 4 KB no I/O); a concorrência é 14 (CPU) ou 100
(I/O). A versão Rx precisa de Observable.FromAsync(() => Task.Run(...)) para o trabalho sair da thread que assina, e
de Merge(maxConcurrent) para limitá-lo. Os quatro deram o mesmo checksum.
Trabalho de CPU (200.000 itens, alguns microssegundos de hash cada):
| Abordagem | ms | itens/s | MB alocados | pico de itens em voo |
|---|---|---|---|---|
Channel<T> limitado a 1000, 14 workers |
460 (356 a 498) | 434.783 | 200 | 1.015 |
Dataflow ActionBlock, limitado a 1000 |
377 (365 a 386) | 530.504 | 200 | 1.001 |
Parallel.ForEachAsync sobre Enumerable.Range |
558 (452 a 650) | 358.423 | 213 | 14 |
Rx Select + Merge(14) |
1063 (1015 a 1201) | 188.147 | 417 | 78.461 |
Trabalho de I/O (20.000 itens, Task.Delay(10) cada, ideal cerca de 2000 ms), como ms, MB alocados, pico de itens em
voo, pico de heap em MB: Channel<T> 2329, 84, 1.101, 29; Dataflow 2347, 90, 1.001, 24; Parallel.ForEachAsync 2398,
87, 100, 7,5; Rx 2400, 110, 19.800, 186.
Quando o trabalho é uma espera, as quatro ficam a cerca de 3% uma da outra: a escolha é memória e formato, não
velocidade. Na CPU, Channel e Dataflow ficaram dentro do ruído, o ForEachAsync foi mais lento, e o Rx levou de 2 a 3
vezes mais tempo e alocou o dobro, com dezenas de milhares de itens criados antes de ficarem prontos (pico de heap de
302 MB), porque o Range emite tudo de uma vez e nada empurra de volta. O pico de heap é amostrado e inclui lixo.
| Se você precisa de | Escolha |
|---|---|
| Uma fila entre produtores e consumidores, o código mais simples | Channel<T> |
| Um laço sobre coleção ou stream com teto de concorrência | Parallel.ForEachAsync (menos memória acima) |
| Vários estágios, paralelismo por estágio, lotes, saída ordenada | Dataflow |
| Operadores de tempo sobre eventos que você não consegue pausar | Rx |
Livro vs hoje
- Dataflow vive no
dotnet/runtime(src/libraries/System.Threading.Tasks.Dataflow) e vem no framework. Em 2026-11-20 a pasta tinha 9 commits desde 2025-11-20 e 21 desde 2024-11-20, quase todos mudanças gerais do repositório (analyzers, polyfills, CI); a única correção de comportamento foi uma corrida noWriteOnceBlock(#123435, fev. de 2026). O pacote ganha uma versão por release de manutenção (10.0.9 a 10.0.15 mensais, 11.0.0 em 2026-11-10). Mantido, sem crescer. Material da era do .NET 4.5 o apresenta como o jeito de montar pipelines; hoje channels eParallel.ForEachAsynccobrem o comum. - Rx: o
dotnet/reactivenão está arquivado, teve commits no dia desta checagem (17 desde 2025-11-20, 47 desde 2024-11-20) e lançou a 7.0.0 em 2026-07-17 (RC em 2026-06-18; a 6.1.0 foi em 2025-10-03). Não tem alvonet10.0(usanet8.0). - Sinais de adoção, não vagas de emprego. Downloads totais no NuGet (incluem restaurações transitivas):
System.Threading.Channels1,66 B, Dataflow 898 M,System.Reactive469 M,System.Linq.Async404 M. Busca de código no GitHub, arquivos C#:using System.Reactive.Linq62.080;Channel.CreateBounded22.496;Parallel.ForEachAsync13.872;ActionBlock<3.960;Task.WhenEach415 (o Rx é forte em UI, não separado aqui). Vagas: não medidas.
Trade-offs
- O Dataflow é verboso. Opções em cada bloco e
AggregateExceptionaninhada dão mais cerimônia que um channel com workers; o ganho é capacidade por estágio, ordenação e lotes. A ordenação custou 371 ms contra 250 ms. - Limite todo bloco e use
SendAsync(7 de 10 chamadas dePostforam rejeitadas acima). Um bloco com falha descarta a fila, então capture por item dentro do delegate e vigie oCompletion. - O Rx empurra o problema para o consumidor. Push sem backpressure enfileirou 199.455 itens; use para eventos, não
para uma fonte finita e rápida que você controla, e descarte toda assinatura (59 MB retidos caso contrário). O
Throttlefaz debounce; para limitar taxa useSampleou um token bucket. - O Rx é um segundo vocabulário, e o
System.Linq.Asyncabaixo da 7.0 não compila no .NET 10.
Documentation Links
- Dataflow (Task Parallel Library), Microsoft Learn
- Walkthrough: Implement a producer-consumer dataflow pattern, Microsoft Learn
- DataflowLinkOptions.PropagateCompletion, Microsoft Learn
- Rx.NET repository, GitHub
- Introduction to Rx.NET, introtorx.com
- Task.WhenEach, Microsoft Learn
- Breaking change: System.Linq.AsyncEnumerable in .NET 10, Microsoft Learn
- AsyncEnumerable class, Microsoft Learn