Dispose и Finalize в C#

FileStream file = new FileStream("important.txt", FileMode.Open);
// Читаем данные
byte[] data = new byte[file.Length];
file.Read(data, 0, (int)file.Length);
// Забыли закрыть файл!
 
// Попытка удалить файл - получим исключение
File.Delete("important.txt"); // Error: The process cannot access the file because it is being used by another process

public interface IDisposable
{
    void Dispose();
}

using (FileStream file = new FileStream("important.txt", FileMode.Open))
{
    // Работаем с файлом
    byte[] data = new byte[file.Length];
    file.Read(data, 0, (int)file.Length);
    // При выходе из блока автоматически вызовется file.Dispose()
}
// Теперь файл можно удалить без проблем
File.Delete("important.txt");

using FileStream file = new FileStream("important.txt", FileMode.Open);
// Работаем с файлом
// Dispose будет вызван автоматически в конце текущей области видимости

public void Dispose()
{
    this.Close();
}

public class ResourceHolder : IDisposable
{
private bool disposed = false;
private IntPtr nativeResource; // Неуправляемый ресурс
private ManagedResource managedResource; // Управляемый ресурс
 
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this); // Предотвращаем вызов финализатора
}
 
protected virtual void Dispose(bool disposing)
{
if (!disposed)
{
if (disposing)
{
// Освобождаем управляемые ресурсы
managedResource?.Dispose();
}
// Освобождаем неуправляемые ресурсы
if (nativeResource != IntPtr.Zero)
{
FreeNativeResource(nativeResource);
nativeResource = IntPtr.Zero;
}
disposed = true;
}
}
 
~ResourceHolder()
{
Dispose(false);
}
}

class MyClass
{
    // Конструктор
    public MyClass()
    {
        // Инициализация
    }
    
    // Финализатор (деструктор)
    ~MyClass()
    {
        // Освобождение ресурсов
    }
}

protected override void Finalize()
{
    try
    {
        // Ваш код финализации
    }
    finally
    {
        base.Finalize();
    }
}

class FinalizationDemo
{
    ~FinalizationDemo()
    {
        Console.WriteLine("Объект финализирован в " + DateTime.Now.ToString("HH:mm:ss.fff"));
    }
    
    public static void Main()
    {
        Console.WriteLine("Создание объекта в " + DateTime.Now.ToString("HH:mm:ss.fff"));
        CreateObject();
        Console.WriteLine("Объект стал недоступен в " + DateTime.Now.ToString("HH:mm:ss.fff"));
        
        // Принудительно вызываем сборку мусора
        GC.Collect();
        GC.WaitForPendingFinalizers();
        
        Console.WriteLine("Сборка мусора завершена в " + DateTime.Now.ToString("HH:mm:ss.fff"));
        Console.ReadKey();
    }
    
    static void CreateObject()
    {
        new FinalizationDemo(); // Объект создается и сразу становится недоступным
    }
}

public class ResourceHolder : IDisposable
{
    private bool disposed = false;
    private IntPtr nativeResource; // Неуправляемый ресурс
    
    protected virtual void Dispose(bool disposing)
    {
        if (!disposed)
        {
            if (disposing)
            {
                // Освобождаем управляемые ресурсы (только в Dispose)
            }
            
            // Освобождаем неуправляемые ресурсы (и в Dispose, и в Finalize)
            if (nativeResource != IntPtr.Zero)
            {
                FreeNativeResource(nativeResource);
                nativeResource = IntPtr.Zero;
            }
            
            disposed = true;
        }
    }
    
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this); // Предотвращаем вызов финализатора
    }
    
    ~ResourceHolder()
    {
        Dispose(false); // Вызывается только для неуправляемых ресурсов
    }
}

class WithoutFinalizer { }
 
class WithFinalizer 
{
    ~WithFinalizer() { }
}
 
void PerformanceTest()
{
    Stopwatch sw = Stopwatch.StartNew();
    
    for (int i = 0; i < 1000000; i++)
    {
        var obj = new WithoutFinalizer();
    }
    
    sw.Stop();
    Console.WriteLine($"Без финализатора: {sw.ElapsedMilliseconds} мс");
    
    sw.Restart();
    
    for (int i = 0; i < 1000000; i++)
    {
        var obj = new WithFinalizer();
    }
    
    sw.Stop();
    Console.WriteLine($"С финализатором: {sw.ElapsedMilliseconds} мс");
}

// Опасный код в финализаторе
~ResourceManager()
{
    // Блокировка может никогда не освободиться, если 
    // основной поток ждёт этот же ресурс
    lock (_syncRoot)
    {
        CloseAllHandles();
    }
}

// Утечка GDI-ресурса
for (int i = 0; i < 10000; i++)
{
    var bitmap = new Bitmap(1000, 1000);
    // Забыли вызвать bitmap.Dispose()
}
// Через некоторое время приложение упадет с OutOfMemoryException

// Опасный код с COM-объектом
Excel.Application excelApp = new Excel.Application();
Excel.Workbook workbook = excelApp.Workbooks.Open("report.xlsx");
// Делаем что-то с документом...
// Забыли освободить ресурсы
 
// Процесс Excel останется в памяти даже после завершения программы!

Excel.Application excelApp = null;
Excel.Workbook workbook = null;
try
{
    excelApp = new Excel.Application();
    workbook = excelApp.Workbooks.Open("report.xlsx");
    // Работа с документом
}
finally
{
    if (workbook != null)
    {
        workbook.Close(false);
        Marshal.ReleaseComObject(workbook);
    }
    if (excelApp != null)
    {
        excelApp.Quit();
        Marshal.ReleaseComObject(excelApp);
    }
}

public class ComplexResource : IDisposable
{
    private bool _disposed = false;
    private ManagedResource _managedResource;
    private IntPtr _unmanagedHandle;
 
    protected virtual void Dispose(bool disposing)
    {
        if (!_disposed)
        {
            if (disposing)
            {
                // Освобождаем управляемые ресурсы
                if (_managedResource != null)
                {
                    _managedResource.Dispose();
                    _managedResource = null;
                }
            }
 
            // Освобождаем неуправляемые ресурсы
            if (_unmanagedHandle != IntPtr.Zero)
            {
                NativeMethods.Release(_unmanagedHandle);
                _unmanagedHandle = IntPtr.Zero;
            }
 
            _disposed = true;
        }
    }
 
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
 
    ~ComplexResource()
    {
        Dispose(false);
    }
}

public class Base : IDisposable
{
    public void Dispose()
    {
        // Освобождение ресурсов базового класса
    }
}
 
public class Derived : Base
{
    public new void Dispose() // Обратите внимание на 'new'!
    {
        // Освобождение ресурсов производного класса
        // Забыли вызвать base.Dispose()!
    }
}

public class Base : IDisposable
{
    private bool _disposed = false;
 
    protected virtual void Dispose(bool disposing)
    {
        if (!_disposed)
        {
            if (disposing)
            {
                // Освобождаем управляемые ресурсы
            }
            // Освобождаем неуправляемые ресурсы
            _disposed = true;
        }
    }
 
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
}
 
public class Derived : Base
{
    private bool _disposed = false;
 
    protected override void Dispose(bool disposing)
    {
        if (!_disposed)
        {
            if (disposing)
            {
                // Освобождаем управляемые ресурсы Derived
            }
            // Освобождаем неуправляемые ресурсы Derived
            _disposed = true;
        }
        base.Dispose(disposing); // Важно!
    }
}

public void DoSomething()
{
    if (_disposed)
    {
        throw new ObjectDisposedException(nameof(ComplexResource));
    }
    
    // Основная логика метода
}

private object _lockObject = new object();
 
public void Dispose()
{
    lock (_lockObject)
    {
        if (!_disposed)
        {
            // Освобождение ресурсов
            _disposed = true;
        }
    }
    GC.SuppressFinalize(this);
}

protected virtual void Dispose(bool disposing)
{
    if (!_disposed)
    {
        if (disposing)
        {
            lock (_lockObject) // Блокировка только для управляемых ресурсов
            {
                // Освобождаем управляемые ресурсы
            }
        }
        
        // Освобождаем неуправляемые ресурсы без блокировки
        
        _disposed = true;
    }
}

public class ResourceManager
{
    private List<IDisposable> _resources = new List<IDisposable>();
    
    public void RegisterResource(IDisposable resource)
    {
        _resources.Add(resource);
    }
    
    public void DisposeAll()
    {
        foreach (var resource in _resources)
        {
            resource.Dispose();
        }
        // Забыли очистить список!
    }
}

public void DisposeAll()
{
    foreach (var resource in _resources)
    {
        resource.Dispose();
    }
    _resources.Clear(); // Очищаем список
}

public class ServiceA : IDisposable
{
    private ServiceB _serviceB;
    
    public ServiceA(ServiceB serviceB)
    {
        _serviceB = serviceB;
    }
    
    public void Dispose()
    {
        _serviceB.DoSomething(); // Если B уже освобожден - получим ошибку
    }
}

public void Dispose()
{
    try
    {
        // Освобождение ресурсов
    }
    catch (Exception)
    {
        // Молчим об ошибке - ужасная практика!
    }
}

public void Dispose()
{
    try
    {
        // Освобождение ресурсов
    }
    catch (Exception ex)
    {
        // Логируем ошибку
        Logger.Error("Failed to dispose resource", ex);
        // Можно перебросить критические исключения
        if (ex is OutOfMemoryException)
            throw;
    }
}

public sealed class DatabaseConnection : IDisposable
{
    private SafeFileHandle _handle;
    
    protected virtual void Dispose(bool disposing)
    {
        if (_handle != null && !_handle.IsInvalid)
        {
            _handle.Dispose(); // SafeHandle позаботится о корректном освобождении
            _handle = null;
        }
    }
}

FileStream fs = new FileStream("data.txt", FileMode.Open);
// Работа с файлом
// Забыли вызвать fs.Dispose() или обернуть в using

protected override void Dispose(bool disposing)
{
    // Освобождаем ресурсы потомка
    // Забыли вызвать base.Dispose(disposing)!
}

public void Dispose()
{
    // Пустой метод - зачем он вообще тут?
}

// RAII в C#
using (var resource = new SomeDisposableResource())
{
    // Используем ресурс
} // Здесь ресурс автоматически освобождается

{
    var resource = new SomeDisposableResource();
    try
    {
        // Используем ресурс
    }
    finally
    {
        if (resource != null)
            ((IDisposable)resource).Dispose();
    }
}

public class DisposableLock : IDisposable
{
    private readonly object _lockObject;
    
    public DisposableLock(object lockObject)
    {
        _lockObject = lockObject;
        Monitor.Enter(_lockObject);
    }
    
    public void Dispose()
    {
        Monitor.Exit(_lockObject);
    }
}
 
// Использование
using (new DisposableLock(_syncRoot))
{
    // Код в критической секции
}

public class ResourceOwner : IDisposable
{
    // Флаг, предотвращающий повторное освобождение ресурсов
    private bool _disposed = false;
    
    // Управляемый ресурс (другой IDisposable объект)
    private ManagedResource _managedResource;
    
    // Неуправляемый ресурс (например, дескриптор файла)
    private IntPtr _unmanagedHandle;
    
    // Защита от многопоточного доступа к Dispose
    private readonly object _lockObject = new object();
    
    // Публичный метод, который вызывается потребителями
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
    
    // Защищенный метод, который может быть переопределен в потомках
    protected virtual void Dispose(bool disposing)
    {
        // Синхронизируем доступ только если вызов из Dispose (не из финализатора)
        if (disposing)
        {
            lock (_lockObject)
            {
                // Проверяем флаг - уже освобождено?
                if (_disposed) return;
                
                // Освобождаем управляемые ресурсы
                if (_managedResource != null)
                {
                    _managedResource.Dispose();
                    _managedResource = null;
                }
            }
        }
        
        // Освобождаем неуправляемые ресурсы
        // Эта часть выполняется и в Dispose, и в финализаторе
        if (_unmanagedHandle != IntPtr.Zero)
        {
            FreeUnmanagedResource(_unmanagedHandle);
            _unmanagedHandle = IntPtr.Zero;
        }
        
        // Устанавливаем флаг - ресурсы освобождены
        _disposed = true;
    }
    
    // Финализатор, вызываемый сборщиком мусора
    ~ResourceOwner()
    {
        // Вызываем Dispose(false), указывая что это вызов из финализатора
        Dispose(false);
    }
    
    // Метод для освобождения неуправляемого ресурса
    private void FreeUnmanagedResource(IntPtr handle)
    {
        // Здесь код для освобождения неуправляемого ресурса
        // например, вызов CloseHandle для Windows-дескрипторов
    }
    
    // Защита публичных методов от использования после Dispose
    public void DoSomething()
    {
        ThrowIfDisposed();
        
        // Основная логика метода...
    }
    
    // Вспомогательный метод для проверки состояния объекта
    private void ThrowIfDisposed()
    {
        if (_disposed)
        {
            throw new ObjectDisposedException(GetType().Name);
        }
    }
}

public class ManagedResourceOwner : IDisposable
{
    private bool _disposed = false;
    private ManagedResource _resource;
    
    public void Dispose()
    {
        if (!_disposed)
        {
            if (_resource != null)
            {
                _resource.Dispose();
                _resource = null;
            }
            _disposed = true;
        }
    }
    
    // Нет финализатора!
}

public class DisposableBase : IDisposable
{
    private bool _disposed = false;
 
    protected virtual void Dispose(bool disposing)
    {
        if (!_disposed)
        {
            if (disposing)
            {
                // Освобождаем управляемые ресурсы базового класса
            }
            
            // Освобождаем неуправляемые ресурсы базового класса
            
            _disposed = true;
        }
    }
 
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
 
    ~DisposableBase()
    {
        Dispose(false);
    }
}
 
public class DisposableDerived : DisposableBase
{
    private bool _disposedDerived = false; // Отдельный флаг для производного класса
    
    protected override void Dispose(bool disposing)
    {
        if (!_disposedDerived)
        {
            if (disposing)
            {
                // Освобождаем управляемые ресурсы производного класса
            }
            
            // Освобождаем неуправляемые ресурсы производного класса
            
            _disposedDerived = true;
        }
        
        // ВАЖНО: Вызываем Dispose базового класса ПОСЛЕ освобождения ресурсов потомка
        base.Dispose(disposing);
    }
    
    // Не нужно переопределять Dispose() или деструктор!
}

public class DisposableBase : IDisposable 
{
    // ... остальной код ...
    
    protected bool IsDisposed => _disposed;
}
 
public class DisposableDerived : DisposableBase
{
    // ... остальной код ...
    
    public void SomeMethod() 
    {
        if (IsDisposed || _disposedDerived)
            throw new ObjectDisposedException(nameof(DisposableDerived));
            
        // Реализация метода
    }
}

public class ResourceScope : IDisposable
{
    private readonly List<IDisposable> _resources = new List<IDisposable>();
    
    public T Register<T>(T resource) where T : IDisposable
    {
        _resources.Add(resource);
        return resource;
    }
    
    public void Dispose()
    {
        foreach (var resource in _resources.Reverse<IDisposable>())
        {
            resource.Dispose();
        }
        _resources.Clear();
    }
}

using (var scope = new ResourceScope())
{
    var connection = scope.Register(new SqlConnection(connectionString));
    connection.Open();
    
    var transaction = scope.Register(connection.BeginTransaction());
    
    // Работаем с транзакцией...
} // Все ресурсы освобождаются автоматически в правильном порядке

WeakReference<BigDataObject> weakRef = new WeakReference<BigDataObject>(largeObject);
 
// Где-то позже в коде
if (weakRef.TryGetTarget(out BigDataObject target))
{
    // Объект еще жив, используем его
}
else
{
    // Объект уже собран GC, создаем новый
}

// using-блок
using (var resource = new SomeResource())
{
    resource.DoWork();
}
 
// эквивалентен
{
    var resource = new SomeResource();
    try
    {
        resource.DoWork();
    }
    finally
    {
        if (resource != null)
            ((IDisposable)resource).Dispose();
    }
}

SqlConnection conn = null;
try
{
    conn = GetConnection(); // может вернуть null
    // работа с соединением
}
finally
{
    conn?.Dispose();
    Logger.Log("Соединение закрыто"); // дополнительные действия
}

// Плохой подход - загружаем всё в память
var allData = File.ReadAllLines("huge_file.csv")
                  .Select(line => ProcessLine(line))
                  .ToList();
 
// Хороший подход - потоковая обработка
using (var reader = new StreamReader("huge_file.csv"))
{
    string line;
    while ((line = reader.ReadLine()) != null)
    {
        var processedData = ProcessLine(line);
        // Обработали и отпустили - память не накапливается
    }
}

private readonly ConcurrentBag<byte[]> _bufferPool = new ConcurrentBag<byte[]>();
 
public byte[] GetBuffer()
{
    if (_bufferPool.TryTake(out byte[] buffer))
        return buffer;
    return new byte[8192]; // Создаем новый, если пул пуст
}
 
public void ReturnBuffer(byte[] buffer)
{
    Array.Clear(buffer, 0, buffer.Length); // Очищаем для безопасности
    _bufferPool.Add(buffer);
}

// Опасный код
public class LongLivedService
{
private List<IDisposable> _resources = new();
 
public void DoSomething(IServiceProvider provider)
{
    var resource = provider.GetService<ITransientResource>();
    _resources.Add(resource); // Утечка! Контейнер не знает об этой ссылке
}
}

public interface IAsyncDisposable
{
    ValueTask DisposeAsync();
}

await using (var resource = new AsyncResource())
{
    // Работаем с ресурсом
} // Здесь вызовется DisposeAsync и выполнится await

public async ValueTask DisposeAsync(CancellationToken token = default)
{
    await _connection.CloseAsync(token);
    // Другие асинхронные операции очистки
}

public async ValueTask DisposeAsync()
{
    // Без ConfigureAwait(false) - возможны дедлоки!
    await _connection.CloseAsync();
}

public async ValueTask DisposeAsync()
{
    // Освобождаем ресурс без захвата контекста
    await _connection.CloseAsync().ConfigureAwait(false);
}

// Никогда не делайте так
var connection = new SqlConnection(connectionString);
connection.Open();
return GetData(connection); // Утечка, если GetData не закроет соединение

public class AsyncResourceWrapper : IDisposable
{
    private DbConnection _connection;
    private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1);
    private bool _disposing = false;
    
    public async Task<T> UseResourceAsync<T>(Func<DbConnection, Task<T>> func)
    {
        await _semaphore.WaitAsync();
        try
        {
            if (_disposing) throw new ObjectDisposedException("Resource");
            return await func(_connection);
        }
        finally
        {
            _semaphore.Release();
        }
    }
    
    public void Dispose()
    {
        _disposing = true;
        // Запускаем асинхронное закрытие без await!
        var task = CloseConnectionAsync();
        // Обрабатываем ошибки закрытия
        task.ContinueWith(t => 
            LogError(t.Exception), TaskContinuationOptions.OnlyOnFaulted);
    }
    
    private async Task CloseConnectionAsync()
    {
        await _semaphore.WaitAsync();
        try { await _connection.CloseAsync(); }
        finally { _semaphore.Release(); }
    }
}