Правильное использование интерфейса IDisposable в C#: как избежать утечек памяти

Основная проблема: управление неуправляемыми ресурсами

Вы затронули очень важную тему. GC (Garbage Collector) в C# занимается только управляемой памятью (managed memory) — объектами в куче. Он НЕ освобождает неуправляемые ресурсы (unmanaged resources): файловые дескрипторы, соединения с БД, сокеты, GDI-объекты и т.д. Если не вызвать Dispose(), эти ресурсы останутся занятыми до перезапуска приложения или до вызова финализатора (деструктора), который происходит непредсказуемо поздно.

Когда нужно реализовывать IDisposable?

Реализуйте IDisposable в вашем классе, если он напрямую владеет неуправляемым ресурсом (через IntPtr, Handle) или содержит поля, которые реализуют IDisposable. В вашем случае — да, нужно.

Правильная реализация паттерна Dispose

Вот стандартный и безопасный паттерн, рекомендованный Microsoft:

public class FileProcessor : IDisposable
{
    private StreamReader _reader;
    private SqlConnection _connection;
    private bool _disposed = false;

    public void ProcessFile(string path)
    {
        // Лучше использовать using для вложенных ресурсов
        using (var reader = new StreamReader(path))
        using (var connection = new SqlConnection("..."))
        {
            // работаем
        } // здесь автоматически вызовется Dispose()
    }

    // Публичный метод Dispose
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this); // не вызывать финализатор
    }

    // Защищённый виртуальный метод
    protected virtual void Dispose(bool disposing)
    {
        if (_disposed) return;

        if (disposing)
        {
            // Освобождаем управляемые ресурсы (IDisposable поля)
            _reader?.Dispose();
            _connection?.Dispose();
        }

        // Освобождаем неуправляемые ресурсы (если есть)
        // _handle.Release(); - пример

        _disposed = true;
    }

    // Финализатор (деструктор) — только если есть неуправляемые ресурсы
    ~FileProcessor()
    {
        Dispose(false);
    }
}

Ключевые моменты паттерна:

• Флаг _disposed — защита от повторного освобождения.
• Dispose(true) — освобождает всё (вызывается из публичного Dispose).
• Dispose(false) — освобождает только неуправляемые ресурсы (вызывается из финализатора).
• GC.SuppressFinalize(this) — если мы сами вызвали Dispose, не нужно ждать финализатора. Это ускоряет сборку мусора.
• Финализатор нужен только если есть прямой неуправляемый ресурс (например, IntPtr). Если все ресурсы — управляемые (StreamReader, SqlConnection), финализатор не обязателен.

Блок using — ваш лучший друг

Блок using гарантирует вызов Dispose() даже при исключении:

public void ProcessFile(string path)
{
    using (var reader = new StreamReader(path))
    using (var connection = new SqlConnection("..."))
    {
        connection.Open();
        string line;
        while ((line = reader.ReadLine()) != null)
        {
            // работаем
            // если здесь исключение — using вызовет Dispose()
        }
    } // reader.Dispose() и connection.Dispose() будут вызваны
}

Если ваш класс сам управляет ресурсами, оберните его в using при использовании:

using (var processor = new FileProcessor())
{
    processor.ProcessFile("file.txt");
} // автоматически вызовется processor.Dispose()

Что делать с исключениями?

Используйте using или try-finally:

StreamReader reader = null;
try
{
    reader = new StreamReader(path);
    // работаем
}
finally
{
    reader?.Dispose(); // гарантированно освободится
}

В современных версиях C# (8.0+) можно использовать using declaration:

public void ProcessFile(string path)
{
    using var reader = new StreamReader(path);
    using var connection = new SqlConnection("...");
    // reader и connection будут освобождены при выходе из метода
}

Заключение

Всегда освобождайте ресурсы, реализующие IDisposable. Используйте using блоки — это самый простой и безопасный способ. Если ваш класс владеет такими ресурсами, реализуйте IDisposable по приведённому паттерну. Помните: GC не освобождает файлы, соединения и хендлы — это ваша ответственность.

public class FileProcessor : IDisposable
{
    private readonly StreamReader _reader;
    private readonly SqlConnection _connection;
    private bool _disposed;

    public FileProcessor(string path, string connectionString)
    {
        _reader = new StreamReader(path);
        _connection = new SqlConnection(connectionString);
    }

    public void Dispose()
    {
        if (_disposed) return;
        
        _reader.Dispose();
        _connection.Dispose();
        _disposed = true;
    }
}