Урок 8.8 — Контекстный менеджер using

В C# есть сборщик мусора (GC), который освобождает память от неиспользуемых объектов. Но GC не управляет неуправляемыми ресурсами: файловые дескрипторы, подключения к БД, сокеты, графические объекты GDI+.

// ❌ ПЛОХО: файл может не закрыться
static void ReadFileBad()
{
    var reader = new StreamReader("file.txt");
    string content = reader.ReadToEnd();
    Console.WriteLine(content);
    // Если до reader.Close() произойдёт исключение —
    // файл останется открытым!
    reader.Close();
}

// ❌ ПЛОХО: ручное управление — легко забыть
static void ReadFileMessy()
{
    var reader = new StreamReader("file.txt");
    try
    {
        string content = reader.ReadToEnd();
        Console.WriteLine(content);
    }
    finally
    {
        reader.Close();  // гарантированно закроем
    }
}

Ручное управление через try-finally работает, но оно громоздкое и подвержено ошибкам. Особенно когда нужно открыть несколько ресурсов.

Конструкция using — это синтаксический сахар для паттерна try-finally. Она гарантирует, что метод Dispose() будет вызван по завершении блока, даже при исключении.

// ✅ ХОРОШО: using гарантирует закрытие
static void ReadFileGood()
{
    using (var reader = new StreamReader("file.txt"))
    {
        string content = reader.ReadToEnd();
        Console.WriteLine(content);
    }
    // reader.Dispose() вызван автоматически
}

// Можно вкладывать using друг в друга:
using (var reader = new StreamReader("input.txt"))
using (var writer = new StreamWriter("output.txt"))
{
    string line;
    while ((line = reader.ReadLine()) != null)
    {
        writer.WriteLine(line.ToUpper());
    }
}

IDisposable — это интерфейс, содержащий единственный метод Dispose(). Любой класс, который использует неуправляемые ресурсы, должен реализовать IDisposable. Конструкция using работает только с объектами, реализующими IDisposable.

public class FileManager : IDisposable
{
    private FileStream? _stream;
    private bool _disposed = false;

    public FileManager(string filePath)
    {
        _stream = File.Open(filePath, FileMode.OpenOrCreate);
        Console.WriteLine($"Файл {filePath} открыт");
    }

    public void WriteData(string data)
    {
        if (_disposed)
            throw new ObjectDisposedException(nameof(FileManager));

        byte[] bytes = System.Text.Encoding.UTF8.GetBytes(data);
        _stream?.Write(bytes, 0, bytes.Length);
    }

    public void Dispose()
    {
        if (!_disposed)
        {
            _stream?.Close();
            _stream?.Dispose();
            _stream = null;
            _disposed = true;
            Console.WriteLine("Ресурсы освобождены");
        }
    }
}

// Использование:
using (var fm = new FileManager("test.txt"))
{
    fm.WriteData("Hello, World!");
}  // Dispose() вызван автоматически

До появления using (C# 1.0) разработчики использовали try-finally. Эта конструкция тоже гарантирует выполнение кода в блоке finally, независимо от того, было ли исключение.

// Эквивалент using через try-finally:
StreamReader reader = null;
try
{
    reader = new StreamReader("file.txt");
    Console.WriteLine(reader.ReadToEnd());
}
finally
{
    if (reader != null)
        reader.Dispose();
}

// То же самое с using:
using (var r = new StreamReader("file.txt"))
{
    Console.WriteLine(r.ReadToEnd());
}

// using короче, читабельнее и не требует ручной проверки на null!

Начиная с C# 8.0, появилась более лаконичная форма — using declaration. Теперь не нужно писать фигурные скобки: ресурс будет освобождён в конце текущей области видимости.

// C# 8+ — using declaration:
static void ReadFileModern()
{
    using var reader = new StreamReader("file.txt");
    string content = reader.ReadToEnd();
    Console.WriteLine(content);
    // Dispose() будет вызван при выходе из метода
}

// Сравните с классическим using:
static void ReadFileClassic()
{
    using (var reader = new StreamReader("file.txt"))
    {
        string content = reader.ReadToEnd();
        Console.WriteLine(content);
    }
}

// Using declaration удобен для нескольких ресурсов:
static void ProcessFiles()
{
    using var input = new StreamReader("input.txt");
    using var output = new StreamWriter("output.txt");

    string? line;
    while ((line = input.ReadLine()) != null)
    {
        output.WriteLine(line.ToUpper());
    }
    // input и output будут освобождены в обратном порядке
}

Многие классы .NET реализуют IDisposable. Вот наиболее часто используемые:

using var reader = new StreamReader("data.txt");
string firstLine = reader.ReadLine() ?? "";

using var writer = new StreamWriter("output.txt");
writer.WriteLine("Hello");

using var connection = new SqlConnection("connection string");
connection.Open();
// работа с БД
// соединение автоматически закроется при выходе из блока

// ⚠️ Внимание: HttpClient обычно используют как static/singleton
// Но в краткосрочных сценариях:
using var client = new HttpClient();
var response = await client.GetStringAsync("https://example.com");
Console.WriteLine(response);