IDisposable en C#: cómo no matar el rendimiento de la aplicación

IDisposable: el arma secreta del rendimiento que las documentaciones callan

¿Alguna vez te has preguntado por qué tu aplicación C# empieza a «ir lenta» después de varias horas de funcionamiento? ¿O por qué la base de datos de repente deja de responder a las consultas? En el 80% de los casos, el culpable es una interfaz —o más bien, su uso incorrecto. Hablamos de IDisposable.

En Stack Overflow, la pregunta «Proper use of the IDisposable interface» ha acumulado miles de visitas y cientos de discusiones. Y no es casualidad: el manejo incorrecto de recursos es el principal enemigo del rendimiento en .NET. Analicemos cómo convertir IDisposable de «magia negra» en una poderosa herramienta de optimización.

¿Por qué IDisposable no es solo una «marca» en el código?

Muchos desarrolladores perciben IDisposable como una obligación aburrida: «hay que implementarlo, lo implemento». Pero en realidad es tu principal aliado en la lucha por el rendimiento. Imagina que tu aplicación es una oficina. Garbage Collector (GC) es el limpiador que viene por la noche. E IDisposable es tu asistente personal, que limpia la basura de inmediato, sin esperar a la mañana.

Sin un uso correcto de IDisposable, corres el riesgo de:

• Fugas de memoria (memory leaks)
• Bloqueo de archivos y conexiones a la BD
• Caídas inesperadas de rendimiento
• Problemas de escalabilidad

Fundamentos: ¿qué es IDisposable y cómo funciona?

IDisposable es una interfaz que contiene solo un método: Dispose(). Su tarea es liberar recursos no administrados (archivos, conexiones de red, identificadores de ventanas) inmediatamente, tan pronto como ya no sean necesarios.

public class ResourceHolder : IDisposable{    private IntPtr _unmanagedResource;    private bool _disposed = false;

    public void Dispose()    {        Dispose(true);        GC.SuppressFinalize(this);    }

    protected virtual void Dispose(bool disposing)    {        if (_disposed) return;

        if (disposing)        {            // Liberamos recursos administrados        }

        // Liberamos recursos no administrados        if (_unmanagedResource != IntPtr.Zero)        {            Marshal.FreeHGlobal(_unmanagedResource);            _unmanagedResource = IntPtr.Zero;        }

        _disposed = true;    }

    ~ResourceHolder()    {        Dispose(false);    }}

Observa GC.SuppressFinalize(this) — este es un punto clave de optimización. Cuando llamas explícitamente a Dispose, le dices a GC: «No invoques el finalizador, ya hice todo». Esto acelera la recolección de basura.

Patrón Dispose: evolución de lo simple a lo complejo

Nivel 1: El más simple (solo para recursos administrados)

Si tu clase solo usa recursos administrados (otros objetos IDisposable), basta con una implementación simple:

public class SimpleLogger : IDisposable{    private readonly FileStream _logFile;

    public SimpleLogger(string path)    {        _logFile = new FileStream(path, FileMode.Append);    }

    public void Dispose()    {        _logFile?.Dispose();    }}

Nivel 2: Patrón completo (con finalizador)

Para clases que trabajan con recursos no administrados (por ejemplo, handles de WinAPI), se necesita el patrón completo con finalizador:

public class SafeHandleWrapper : IDisposable{    private SafeHandle _handle;

    public SafeHandleWrapper()    {        _handle = new SafeFileHandle(IntPtr.Zero, true);    }

    public void Dispose()    {        Dispose(true);        GC.SuppressFinalize(this);    }

    protected virtual void Dispose(bool disposing)    {        if (_handle != null && !_handle.IsInvalid)        {            _handle.Dispose();        }    }

    // El finalizador solo es necesario si hay