Forem: Danilo Maia Florenzano

Using ActionBlock as a Multithread Recursive Dynamic Queue in .NET

Danilo Maia Florenzano — Sun, 02 Nov 2025 16:29:54 +0000

“TPL Dataflow is an interesting mix of asynchronous and parallel technologies. It’s useful when you have a sequence of processes that need to be applied to your data.”

— Stephen Cleary, Concurrency in C# Cookbook

I recently needed to traverse a recursive category tree — starting with ~20 root nodes, each with an unknown number of subcategories (and sub-subcategories, and so on).

This kind of dynamically expanding workload doesn’t play well with static parallelization tools like Parallel.ForEach.

The Problem: Static Work Distribution

If we run Parallel.ForEach on the 20 root categories:

Thread 1 might get a small branch and finish in 1 second.
Thread 2 might get a massive branch and take 10 minutes.

Even with MaxDegreeOfParallelism = 50, most threads finish early and go idle — while a few get stuck processing deep, heavy trees. Load imbalance and wasted resources.

The Solution: `ActionBlock<T>` as a Dynamic Work Queue

ActionBlock<T> from TPL Dataflow provides a centralized, thread-safe queue with dynamic task generation and controlled concurrency.

Here’s how it works:

Create one ActionBlock<CategoryNode> with a fixed concurrency limit.
“Prime” it with the initial root categories.
Each worker processes its node, finds subcategories, and posts them back into the same ActionBlock.
The block keeps running until all items (current + pending) are done.

This pattern is effectively a recursive, self-balancing queue — all threads stay busy until the entire tree is processed.

Example Implementation

public class MultithreadTreeParser
{
    private int _activeItems;
    private ActionBlock<CategoryNode> _actionBlock = null!;

    public async Task<int> StartAsync()
    {
        var rootNode = await GetDepartmentsRootNodeAsync()
            ?? throw new Exception("Failed to get root node");

        var options = new ExecutionDataflowBlockOptions
        {
            MaxDegreeOfParallelism = 5
        };

        _actionBlock = new ActionBlock<CategoryNode>(async node =>
        {
            try
            {
                await ProcessCategoryAsync(node);

                var subs = node.SubCategories;
                if (subs.Count > 0)
                {
                    Interlocked.Add(ref _activeItems, subs.Count);
                    foreach (var sub in subs)
                        await _actionBlock.SendAsync(sub);
                }
            }
            finally
            {
                var remaining = Interlocked.Decrement(ref _activeItems);
                if (remaining == 0)
                    _actionBlock.Complete();
            }
        }, options);

        var rootSubs = rootNode.SubCategories;
        Interlocked.Add(ref _activeItems, rootSubs.Count);

        foreach (var sub in rootSubs)
            await _actionBlock.SendAsync(sub);

        await _actionBlock.Completion;
        return 0;
    }
}

Why This Works

Dynamic load balancing: Workers pull from a shared queue. As soon as they finish, they grab the next available node.
Recursive workload expansion: Each task can add new tasks safely to the same queue.
Controlled parallelism: MaxDegreeOfParallelism keeps resource usage in check.
Clean completion tracking: _activeItems counts in-flight work — when it hits zero, the pipeline gracefully completes.

Dumb HTTP Server in C# .NET

Danilo Maia Florenzano — Sat, 21 Jun 2025 22:25:38 +0000

I saw this video where the server was coded in Rust. If you're trying to learn how it works, maybe it will be useful.

Coding a Web Server in 25 Lines - Computerphile

If you want to just copy and paste the code and see it working, make sure you have an index.html file in the project folder.

Code sample

TcpListener class description:

The System.Net.Sockets.TcpListener class provide TCP services at a higher level of abstraction than the System.Net.Sockets.Socket class. System.Net.Sockets.TcpListener is used to create a host process that listens for connections from TCP clients.

using System.Net;
using System.Net.Sockets;
using System.Text;

var tcpListener = new TcpListener(IPAddress.Loopback, 9999);
tcpListener.Start();

while (true)
{
    using var handler = tcpListener.AcceptTcpClient();
    await using var stream = handler.GetStream();

    var reader = new StreamReader(stream);

    while (true)
    {
        var line = reader.ReadLine();
        Console.WriteLine(line);
        if (string.IsNullOrWhiteSpace(line)) break;
    }

    const string okResponse = "HTTP/1.1 200 OK\r\n\r\n";
    await stream.WriteAsync(Encoding.UTF8.GetBytes(okResponse));

    var projectPath = new DirectoryInfo(Directory.GetCurrentDirectory())
        .Parent!.Parent!.Parent!.FullName;

    var htmlBuffer = Encoding.UTF8.GetBytes(File.ReadAllText(Path.Combine(projectPath, "index.html")));
    await stream.WriteAsync(htmlBuffer);
}

Example

In the server console:

GET / HTTP/1.1
Host: 127.0.0.1:9999
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:139.0) Gecko/20100101 Firefox/139.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-GB,en;q=0.5
Accept-Encoding: gzip, deflate, br, zstd
Connection: keep-alive
Upgrade-Insecure-Requests: 1
Sec-Fetch-Dest: document
Sec-Fetch-Mode: navigate
Sec-Fetch-Site: none
Sec-Fetch-User: ?1
Priority: u=0, i

POO: Herança versus Composição

Danilo Maia Florenzano — Sun, 08 Jun 2025 15:56:25 +0000

Como decidir

Usar herança quando precisar de:

reaproveitamento de código
polimorfismo

Usar composição quando precisar de:

reaproveitamento de código

Usar uma interface quando precisar de:

polimorfismo

Ou seja, a herança é bem vinda quando, e somente quando, as duas necessidades forem verdade. Do contrario, prefira sempre composição.

É importante ressaltar que a herança pode levar a um acoplamento mais forte entre as classes, o que pode dificultar a manutenção e evolução do código.
A composição, por outro lado, promove um acoplamento mais fraco, permitindo maior flexibilidade e reutilização de componentes. Por isso, muitos autores recomendam a composição como uma abordagem preferencial na Programação Orientada a Objetos.

Exemplo

No exemplo da imagem, a herança não é justificada porque nenhuma das classes herdeiras sobrescreve o método da classe principal (polimorfismo), apenas é reaproveitado o Metodo1() (reaproveitamento de código).
Nesse caso, como apenas um dos requisitos é preenchido, é melhor usar composição.

Há também a abordagem de não usar herança mesmo em casos que preencham os dois requisitos. Pois ambos podem ser satisfeitos através da combinação de interfaces e composição.

Referência

Only Use Inheritance If You Want Both of These - by Christopher Okhravi

Podman com Quadlets em produção

Danilo Maia Florenzano — Fri, 06 Jun 2025 22:52:41 +0000

Aluguei uma VPS e queria disponibilizar uma API que desenvolvi.

Optei por utilizar contêineres. A escolha do Podman foi feita considerando o objetivo de melhorar minha afinidade com a ferramenta e, também, usufruir da integração nativa com o systemd.

Para atingir um resultado satisfatório, considerando a inicialização dos contêineres no boot e a possibilidade de acompanhar logs pelo journalctl, executei os seguintes passos:

Criei um pod com os contêineres necessários.

Gerei um arquivo YAML para Kubernetes a partir do pod:

podman generate kube xpto-pod -f /tmp/my_pod_kube.yaml

Criei um arquivo .kube, referenciando o .yaml gerado:

xpto-pod.kube

[Unit]
Description=Serviço XPTO
After=network-online.target
Wants=network-online.target

[Install]
WantedBy=multi-user.target

[Service]
Restart=on-failure
RestartSec=5s
TimeoutStartSec=900

[Kube]
Yaml=/tmp/my_pod_kube.yaml
PublishPort=8080:80
LogDriver=journald
SetWorkingDirectory=yaml
KubeDownForce=true

Obs: A seção [Install] é essencial para que o systemd inicie o pod automaticamente no boot.

Movi o arquivo para a pasta correta:

sudo mv xpto-pod.kube /etc/containers/systemd/

Recarreguei os serviços do systemd:

sudo systemctl daemon-reexec
sudo systemctl daemon-reload

Finalizado! Para verificar se o serviço está em execução:
```
systemctl status xpto-pod.service
```

Continuo explorando formas de usar o Podman e suas ferramentas e integrações.

Fontes que utilizei para alcançar esse resultado:

O André Darcie trouxe a true bem sintetizada. Blazor não vai morrer, mas é necessário conhecer suas limitações e seu propósito para saber identificar seus casos de uso.

Danilo Maia Florenzano — Tue, 10 Dec 2024 12:46:04 +0000

O Futuro do Blazor

André N. Darcie ・ Dec 9 '24

#webdev #dotnet #blazor #braziliandevs