# Monitorear memoria de procesos .NET en Linux/WSL
El trabajo pesado en .NET, como OCR, generación de PDF o procesamiento de imágenes, puede ser difícil de dimensionar en entornos restringidos como WSL (Subsistema de Windows para Linux) o contenedores Linux. Puede registrar el uso de memoria de un proceso en tiempo real directamente desde una aplicación de consola, o observarla externamente con herramientas estándar de Linux.
## Requisitos previos
- SDK de .NET instalado, versión `5.0` o posterior.
- Un entorno Linux, ya sea nativo o a través de WSL.
- Una aplicación de consola básica de .NET.
## Solución
### 1. Registrar el uso de memoria en la consola
Lea el tamaño de memoria privada del proceso e imprímalo en 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` devuelve la cantidad de memoria, en bytes, que el proceso ha asignado exclusivamente y no comparte con otros procesos. Es un indicador sólido de qué tan cargada está su aplicación.
### 2. Rastrear memoria continuamente
Para un proceso de larga duración, envuelva la lectura en un ciclo para muestrear el uso a lo largo del tiempo:
```csharp
while (true)
{
var memory = Process.GetCurrentProcess().PrivateMemorySize64;
Console.WriteLine($"Memory Usage: {memory / (1024 * 1024)} MB");
Thread.Sleep(5000); // Log every 5 seconds
}
```
La llamada `Thread.Sleep(5000)` programa el registro para una lectura cada cinco segundos. Dirija la salida a un archivo u otro proceso, o úselos para disparar alertas cuando el uso supere un umbral.
#### Salida de consola
```txt
Memory Usage: 214 MB
```
### Opción: Monitorear externamente con herramientas de Linux
Para observar un proceso desde fuera de la aplicación, use una de las utilidades estándar. `<pid>` es el ID de Proceso, el número único que el sistema operativo asigna a cada proceso en ejecución.
**`top` o `htop`:** observa un solo proceso en vivo.
```bash
top -p <pid>
```
**`ps`:** imprime una captura instantánea de campos de memoria.
```bash
ps -o pid,vsz,rss,comm -p <pid>
```
Aquí `VSZ` es el tamaño de memoria virtual en KB y `RSS` es el tamaño del conjunto residente, la memoria física en uso.
**`smem`:** instálalo para un desglose más detallado por proceso.
```bash
sudo apt install smem
smem -p <pid>
```
## Bestes prácticas
- Ejecute seguimiento de memoria en entornos de prueba antes de despliegue en producción.
- Para servicios o APIs de larga duración, integre un conjunto de métricas como Prometheus o Grafana.
- Reserva `GC.Collect()` solo para la depuración.
[[w:(No llame a GC.Collect() en código de producción; úselo solo durante la depuración.)]]
El trabajo pesado en .NET, como OCR, generación de PDF o procesamiento de imágenes, puede ser difícil de dimensionar en entornos restringidos como WSL (Subsistema de Windows para Linux) o contenedores Linux. Puede registrar el uso de memoria de un proceso en tiempo real directamente desde una aplicación de consola, o observarla externamente con herramientas estándar de Linux.
Requisitos previos
SDK de .NET instalado, versión 5.0 o posterior.
Un entorno Linux, ya sea nativo o a través de WSL.
Una aplicación de consola básica de .NET.
Solución
1. Registrar el uso de memoria en la consola
Lea el tamaño de memoria privada del proceso e imprímalo en 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 devuelve la cantidad de memoria, en bytes, que el proceso ha asignado exclusivamente y no comparte con otros procesos. Es un indicador sólido de qué tan cargada está su aplicación.
2. Rastrear memoria continuamente
Para un proceso de larga duración, envuelva la lectura en un ciclo para muestrear el uso a lo largo del tiempo:
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#
La llamada Thread.Sleep(5000) programa el registro para una lectura cada cinco segundos. Dirija la salida a un archivo u otro proceso, o úselos para disparar alertas cuando el uso supere un umbral.
Salida de consola
Memory Usage: 214 MB
Memory Usage: 214 MB
Text
Opción: Monitorear externamente con herramientas de Linux
Para observar un proceso desde fuera de la aplicación, use una de las utilidades estándar. <pid> es el ID de Proceso, el número único que el sistema operativo asigna a cada proceso en ejecución.
top o htop: observa un solo proceso en vivo.
top -p <pid>
top -p <pid>
SHELL
ps: imprime una captura instantánea de campos de memoria.
ps -o pid,vsz,rss,comm -p <pid>
ps -o pid,vsz,rss,comm -p <pid>
SHELL
Aquí VSZ es el tamaño de memoria virtual en KB y RSS es el tamaño del conjunto residente, la memoria física en uso.
smem: instálalo para un desglose más detallado por proceso.
sudo apt install smemsmem -p <pid>
sudo apt install smem
smem -p <pid>
SHELL
Bestes prácticas
Ejecute seguimiento de memoria en entornos de prueba antes de despliegue en producción.
Para servicios o APIs de larga duración, integre un conjunto de métricas como Prometheus o Grafana.
Reserva GC.Collect() solo para la depuración.
Advertencia: No llame a GC.Collect() en código de producción; úselo solo durante la depuración.
Curtis Chau tiene una licenciatura en Ciencias de la Computación (Carleton University) y se especializa en el desarrollo front-end con experiencia en Node.js, TypeScript, JavaScript y React. Apasionado por crear interfaces de usuario intuitivas y estéticamente agradables, disfruta trabajando con frameworks modernos y creando manuales bien estructurados y visualmente atractivos.
