# Monitorar Memória de Processos .NET no Linux/WSL
Trabalhos pesados em .NET, como OCR, geração de PDF ou processamento de imagens, podem ser difíceis de dimensionar em ambientes restritos como WSL (Windows Subsystem for Linux) ou contêineres Linux. Você pode registrar o consumo de memória de um processo em tempo real diretamente de um aplicativo de console, ou assisti-lo externamente com ferramentas padrão do Linux.
## Pré-requisitos
- SDK .NET instalado, versão `5.0` ou superior.
- Um ambiente Linux, nativo ou via WSL.
- Um aplicativo de console básico .NET.
## Solução
### 1. Registrar uso de memória no console
Leia o tamanho da memória privada do processo e imprima em megabytes:
```csharp
using System;
using System.Diagnostics;
class Program
{
static void Main(string[] args)
{
// Trigger your memory-consuming logic here (e.g., OCR, PDF generation, etc.)
// Log memory usage
Process currentProcess = Process.GetCurrentProcess();
long memorySize = currentProcess.PrivateMemorySize64; // In bytes
Console.WriteLine($"Memory Usage: {memorySize / (1024 * 1024)} MB");
}
}
```
`PrivateMemorySize64` retorna a quantidade de memória, em bytes, que o processo alocou exclusivamente e não compartilha com outros processos. É um sólido indicador de quão pesado seu aplicativo está rodando.
### 2. Monitorar memória continuamente
Para um processo de longa duração, envolva a leitura em um loop para amostrar o uso ao longo do tempo:
```csharp
while (true)
{
var memory = Process.GetCurrentProcess().PrivateMemorySize64;
Console.WriteLine($"Memory Usage: {memory / (1024 * 1024)} MB");
Thread.Sleep(5000); // Log every 5 seconds
}
```
A chamada `Thread.Sleep(5000)` ajusta o registro para uma leitura a cada cinco segundos. Encaminhe a saída para um arquivo ou outro processo, ou use-a para disparar alertas quando o uso ultrapassar um limite.
#### Saída do console
```txt
Memory Usage: 214 MB
```
### Opção: Monitorar externamente com ferramentas Linux
Para assistir um processo de fora do aplicativo, use uma das utilitários padrão. `<pid>` é o ID do Processo, o número único que o sistema operacional atribui a cada processo em execução.
**`top` ou `htop`:** observe um único processo ao vivo.
```bash
top -p <pid>
```
**`ps`:** imprima um instantâneo único de campos de memória.
```bash
ps -o pid,vsz,rss,comm -p <pid>
```
Aqui `VSZ` é o tamanho da memória virtual em KB e `RSS` é o tamanho do conjunto residente, a memória física em uso.
**`smem`:** instale-o para uma análise mais detalhada de cada processo.
```bash
sudo apt install smem
smem -p <pid>
```
## Melhores práticas
- Execute o acompanhamento de memória em ambientes de teste antes de implantar para produção.
- Para serviços ou APIs de longa duração, integre uma stack de métricas como Prometheus ou Grafana.
- Reserve `GC.Collect()` apenas para depuração.
[[w:(Não chame GC.Collect() em código de produção; use-o apenas enquanto estiver depurando.)]]
Trabalhos pesados em .NET, como OCR, geração de PDF ou processamento de imagens, podem ser difíceis de dimensionar em ambientes restritos como WSL (Windows Subsystem for Linux) ou contêineres Linux. Você pode registrar o consumo de memória de um processo em tempo real diretamente de um aplicativo de console, ou assisti-lo externamente com ferramentas padrão do Linux.
Pré-requisitos
SDK .NET instalado, versão 5.0 ou superior.
Um ambiente Linux, nativo ou via WSL.
Um aplicativo de console básico .NET.
Solução
1. Registrar uso de memória no console
Leia o tamanho da memória privada do processo e imprima em megabytes:
using System;using System.Diagnostics;class Program{static voidMain(string[] args){// Trigger your memory-consuming logic here (e.g., OCR, PDF generation, etc.)// Log memory usageProcess currentProcess = Process.GetCurrentProcess();long memorySize = currentProcess.PrivateMemorySize64; // In bytesConsole.WriteLine($"Memory Usage: {memorySize / (1024 * 1024)} MB");}}
using System;
using System.Diagnostics;
class Program
{
static void Main(string[] args)
{
// Trigger your memory-consuming logic here (e.g., OCR, PDF generation, etc.)
// Log memory usage
Process currentProcess = Process.GetCurrentProcess();
long memorySize = currentProcess.PrivateMemorySize64; // In bytes
Console.WriteLine($"Memory Usage: {memorySize / (1024 * 1024)} MB");
}
}
C#
PrivateMemorySize64 retorna a quantidade de memória, em bytes, que o processo alocou exclusivamente e não compartilha com outros processos. É um sólido indicador de quão pesado seu aplicativo está rodando.
2. Monitorar memória continuamente
Para um processo de longa duração, envolva a leitura em um loop para amostrar o uso ao longo do tempo:
while (true){var memory = Process.GetCurrentProcess().PrivateMemorySize64;Console.WriteLine($"Memory Usage: {memory / (1024 * 1024)} MB");Thread.Sleep(5000); // Log every 5 seconds}
while (true)
{
var memory = Process.GetCurrentProcess().PrivateMemorySize64;
Console.WriteLine($"Memory Usage: {memory / (1024 * 1024)} MB");
Thread.Sleep(5000); // Log every 5 seconds
}
C#
A chamada Thread.Sleep(5000) ajusta o registro para uma leitura a cada cinco segundos. Encaminhe a saída para um arquivo ou outro processo, ou use-a para disparar alertas quando o uso ultrapassar um limite.
Saída do console
Memory Usage: 214 MB
Memory Usage: 214 MB
Text
Opção: Monitorar externamente com ferramentas Linux
Para assistir um processo de fora do aplicativo, use uma das utilitários padrão. <pid> é o ID do Processo, o número único que o sistema operacional atribui a cada processo em execução.
top ou htop: observe um único processo ao vivo.
top -p <pid>
top -p <pid>
SHELL
ps: imprima um instantâneo único de campos de memória.
ps -o pid,vsz,rss,comm -p <pid>
ps -o pid,vsz,rss,comm -p <pid>
SHELL
Aqui VSZ é o tamanho da memória virtual em KB e RSS é o tamanho do conjunto residente, a memória física em uso.
smem: instale-o para uma análise mais detalhada de cada processo.
sudo apt install smemsmem -p <pid>
sudo apt install smem
smem -p <pid>
SHELL
Melhores práticas
Execute o acompanhamento de memória em ambientes de teste antes de implantar para produção.
Para serviços ou APIs de longa duração, integre uma stack de métricas como Prometheus ou Grafana.
Reserve GC.Collect() apenas para depuração.
Aviso: Não chame GC.Collect() em código de produção; use-o apenas enquanto estiver depurando.
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.
