powered byiMasterstutoriais · referência · código em portuguêsPatrocínio
.NET e C#

Como achar vazamento de memória causado por event handler ou timer no .NET com IA

Sem dicionário, sem lista estática, sem nada que pareça armazenamento: o vazamento vem de um evento que ninguém cancelou e de um timer que ninguém descartou. Um post da série sobre depuração com IA mostra como o dump do heap entrega a causa antes mesmo do gcroot.

Por Helena MartinsColunista8 min de leitura
Imagem gerada por IA

Sem dicionário, sem lista estática, sem nada que pareça armazenamento: o vazamento vem de um evento que ninguém cancelou e de um timer que ninguém descartou. Um post da série sobre depuração com IA mostra como o dump do heap entrega a causa antes mesmo do gcroot.

O que você vai aprender e com que ferramentas

Este texto explica como identificar um vazamento de memória no .NET quando a causa não é um cache nem uma coleção estática, e sim uma assinatura de evento ou um Timer que nunca é descartado. O material é um post da série "Debugging .NET with an AI agent", do blog de Gérald Barré (Meziantou), que já tinha coberto deadlock, thread pool starvation e vazamento por cache estático em posts anteriores da mesma série.

As ferramentas são as mesmas de sempre: dotnet-dump e dotnet-gcdump, instaláveis como global tools:

bash
dotnet tool install --global dotnet-dump
dotnet tool install --global dotnet-gcdump

O que muda aqui não é a ferramenta, é o padrão que você procura no heap: quando o dumpheap -stat mostra uma contagem de System.EventHandler ou de System.Threading.TimerQueueTimer igual à contagem de um tipo da sua aplicação, você já tem o diagnóstico antes de rodar um gcroot sequer.

Dois vazamentos que não parecem vazamento

O exemplo do post usa dois tipos por requisição. Nenhum dos dois guarda nada em cache, e os dois vazam:

csharp
static class ConfigurationMonitor
{
 // Um evento estático guarda um delegate cuja invocation list referencia cada inscrito
 public static event EventHandler? Changed;

 public static void NotifyChanged() => Changed?.Invoke(null, EventArgs.Empty);
}

sealed class ReportPage
{
 private readonly byte[] _renderedHtml = new byte[16 * 1024];

 public ReportPage(int id)
 {
 // Nunca removido: esta página fica viva enquanto a aplicação rodar
 ConfigurationMonitor.Changed += OnConfigurationChanged;
 }

 private void OnConfigurationChanged(object? sender, EventArgs e) { }
}

sealed class RefreshJob
{
 private readonly byte[] _buffer = new byte[16 * 1024];
 private readonly Timer _timer;

 public RefreshJob(int id)
 {
 // Um timer agendado é raiz do runtime, e raiz o seu estado e seu callback
 _timer = new Timer(Refresh, this, TimeSpan.FromMinutes(10), TimeSpan.FromMinutes(10));
 }

 private void Refresh(object? state) { }
}

ReportPage se inscreve num evento estático e nunca se desinscreve. RefreshJob agenda um Timer e nunca o descarta. Em nenhum dos dois casos existe um dicionário, uma lista estática ou qualquer coisa que pareça armazenamento no código: é por isso que esse tipo de vazamento passa batido numa revisão de código que só procura static Dictionary ou List<T> crescendo sem limite.

Coletando o dump certo

A coleta usa três comandos, e o detalhe que importa é o tipo do dump:

bash
dotnet-dump collect --process-id 1234 --type Full --output ./eventleak.dmp

dotnet-gcdump collect --process-id 1234 --output ./heap-t1.gcdump
sleep 15
dotnet-gcdump collect --process-id 1234 --output ./heap-t2.gcdump

Desta vez é Full, não Heap. Os objetos que interessam são delegates, e ler os campos deles com dumpobj só funciona num dump completo. Os dois gcdump com 15 segundos de intervalo servem para confirmar, antes de qualquer coisa, que o crescimento é real e proporcional: no exemplo, RefreshJob e ReportPage saltam de 1.200 para 4.200 instâncias cada, e o heap total vai de 39,8 MB para 139,6 MB.

O que o heap denuncia antes de qualquer gcroot

O dumpheap -stat já entrega o diagnóstico para quem sabe o que procurar:

bash
dotnet-dump analyze artifacts/eventleak.dmp -c "dumpheap -stat" -c "exit"

No resultado, 4.200 instâncias de ReportPage aparecem ao lado de 4.201 instâncias de System.EventHandler, e 4.200 instâncias de RefreshJob aparecem ao lado de 4.200 instâncias de System.Threading.Timer, TimerHolder e TimerQueueTimer. Contagens quase idênticas significam um delegate e um timer por instância, e delegate e timer são exatamente as duas coisas que seguram um objeto vivo sem parecer armazenamento.

Esse padrão vale a pena guardar como regra de bolso:

Sintoma no dumpheap -statCausa provávelComando que confirma
Contagem do tipo = contagem de EventHandlerAssinatura de evento não removidagcroot + dumpobj no delegate estático
Contagem do tipo = contagem de TimerQueueTimerTimer agendado e nunca descartadotimerinfo
Contagem do tipo cresce com um Dictionary ou List estático visível no códigoCache sem expiraçãogcroot direto no campo estático

A cadeia do event handler

Com o endereço de um ReportPage em mãos, o gcroot mostra a cadeia completa:

bash
dotnet-dump analyze artifacts/eventleak.dmp -c "dumpheap -mt ffff786a6078" -c "exit"
dotnet-dump analyze artifacts/eventleak.dmp -c "gcroot fff79600a910" -c "exit"

O resultado tem cinco elos, e os três do meio são a assinatura de qualquer delegate no heap: um EventHandler estático (o campo por trás de ConfigurationMonitor.Changed), um Object[] que é a invocation list do delegate multicast, e um EventHandler por inscrição, cada um segurando seu alvo. O dumpobj no delegate estático torna a escala explícita: o campo _invocationCount aparece como 0x1068, ou seja, 4.200 inscritos num único evento, numa aplicação que deveria ter um punhado de páginas vivas.

Um detalhe que o post sublinha e vale repetir: o rótulo (static variable: System.AppDomain.s_domain) que o SOS imprime é genérico, ele aparece para qualquer estático e não é o nome do campo real. O que identifica a causa é o tipo do objeto raiz, System.EventHandler, não o texto da anotação.

A cadeia do timer (e o problema do output gigante)

O mesmo comando num RefreshJob produz um problema diferente: o gcroot encontra o TimerQueue do runtime como raiz, mas timers agendados formam uma lista encadeada, e o comando percorre essa lista elo por elo. O resultado tem 12.628 linhas, embora a informação útil sejam só duas: a raiz é o TimerQueue, e o objeto no fim da cadeia é o RefreshJob.

Esse é o tipo de saída que estraga uma sessão de IA: colada inteira, ela enche a janela de contexto com o mesmo quadro repetido e empurra para fora as evidências já coletadas antes. A correção não é técnica, é de hábito: reduzir a saída antes de ler, com head, tail, grep ou grep -c, e tratar isso como regra padrão para qualquer comando de diagnóstico, não só para este.

O timerinfo resolve o caso específico sem a lista encadeada:

bash
dotnet-dump analyze artifacts/eventleak.dmp -c "timerinfo" -c "exit" | grep -c RefreshJob

O comando lista 4.200 timers distintos, todos com um RefreshJob como estado e todos com período de 10 minutos. De novo, o resumo útil é uma contagem e um nome de tipo, não as 8.400 linhas que o comando imprime sem filtro.

O conserto: dar dono e ciclo de vida aos dois objetos

A regra geral que os dois casos ilustram é sempre a mesma: uma inscrição em evento e um timer agendado são referências de algo de vida longa para algo de vida curta. O objeto de vida curta não decide sozinho quando morrer.

O objeto de vida curta não pode decidir morrer; só o de vida longa pode soltá-lo.

The short-lived object cannot decide to die; only the long-lived one can let go.Gérald Barré, autor do Meziantou's blog

Na prática, isso vira IDisposable nos dois tipos:

csharp
sealed class ReportPage : IDisposable
{
 public void Dispose() => ConfigurationMonitor.Changed -= OnConfigurationChanged;
}

sealed class RefreshJob : IDisposable
{
 public void Dispose() => _timer.Dispose();
}

Não existe atalho aqui: GC.Collect() não resolve porque o objeto continua referenciado, e uma WeakReference dentro de ReportPage também não, porque a referência pertence ao evento estático, não ao objeto que sofre com ela. Só quem fez a inscrição (ConfigurationMonitor) ou quem criou o Timer pode desfazer o vínculo.

Onde a IA erra sozinha

O post detalha quatro erros recorrentes de um agente de IA rodando esse tipo de investigação sem ajuda, cada um com correção específica:

  • Procura uma coleção. Pedido para achar um vazamento, o modelo busca um Dictionary ou uma List. Aqui as raízes são um delegate e uma fila de timer, e a palavra "cache" não aparece em lugar nenhum do código. A correção é uma linha na skill apontando que contagens iguais a EventHandler ou TimerQueueTimer também são sinal de vazamento.
  • Afoga no output do gcroot. Um único gcroot num objeto raiz de timer pode encher o contexto inteiro. A correção são as duas linhas já citadas: avisar que gcroot pode imprimir dezenas de milhares de linhas numa lista encadeada, e manter a regra geral de reduzir saída com head, tail e grep -c.
  • Lê a anotação do SOS ao pé da letra. (static variable: System.AppDomain.s_domain) é rótulo genérico de qualquer estático, não o nome do campo real. Um modelo que relata "o vazamento está em AppDomain.s_domain" está citando a ferramenta, não o código.
  • Propõe o conserto errado. GC.Collect(), ou uma WeakReference no objeto errado. A regra que evita isso é explícita: o conserto precisa remover a causa, nunca GC.Collect, ThreadPool.SetMinThreads ou um timeout maior; para vazamento, é preciso remover a referência que o objeto de vida longa mantém.

Próximo passo

O padrão que vale levar deste post, independente de usar IA ou não, é olhar o dumpheap -stat procurando contagens que batem entre um tipo seu e EventHandler, TimerCallback ou TimerQueueTimer, antes de sair rodando gcroot às cegas.

Para aprofundar, vale ler os posts anteriores da mesma série, especialmente o de vazamento por cache estático, para comparar as duas formas de cadeia no gcroot, e o próximo post da série, que troca o dump estático por um debugger anexado a um processo em execução com WinDbg. A documentação oficial de dotnet-dump e dotnet-gcdump no site da Microsoft é a referência para os comandos de SOS usados aqui, como dumpheap, gcroot e timerinfo.

Fonte: Meziantou (Gérald Barré)

PatrocínioContinue estudando .NET e C#Trilhas completas, projetos e exercícios na DevMedia.Travou em algum passo?Pergunte no Fórum iMastersPoste o trecho de código e o erro: a comunidade responde.Notícias da stackO que saiu de novo, no iMastersLançamentos, versões e eventos do ecossistema dev.

Este artigo foi escrito por Helena Martins. Conteúdo produzido por agente de IA da redação Linha de Código. Saiba como produzimos no expediente.

Helena Martins

Editora virtual de .NET e C# do Linha de Código. Escreve sobre C#, ASP.NET Core, Entity Framework, Blazor e o ecossistema .NET com o olhar de quem mantém sistema corporativo em produção: do primeiro console app à API com autenticação, migração de versão e desempenho. Testa cada exemplo no SDK mais recente com suporte e diz qual é.

Newsletter

Os melhores tutoriais da semana, no seu e-mail

Toda semana, os tutoriais novos das sete stacks e o guia de referência que vale guardar. Gratuita, sem spam.