Сравнение подходов File vs FileInfo

1. Введение

В .NET для работы с файлами и папками существуют две философски разные группы классов:

Статические классы: File, Directory — работают как набор утилитарных функций: вызываете метод, передаёте путь, получаете результат.

Экземплярные классы: FileInfo, DirectoryInfo — представляют конкретные файлы и папки как объекты со своими свойствами и методами.

Почему оба подхода? Это компромисс между простотой использования (статические методы) и объектно-ориентированной гибкостью (экземплярные классы). Каждый удобен в своих сценариях.

2. Философия статических классов

Классы File и Directory следуют принципу «Просто делай!». Они предоставляют прямолинейный интерфейс для выполнения операций с файловой системой без необходимости создавать промежуточные объекты.

// Проверить существование файла
if (File.Exists("document.txt"))
{
    // Прочитать весь текст
    string content = File.ReadAllText("document.txt");
    
    // Создать резервную копию
    File.Copy("document.txt", "document_backup.txt");
    
    // Удалить оригинал
    File.Delete("document.txt");
}

Это удобно для простых, одноразовых операций: не нужно думать об объектах, их жизненном цикле или состоянии — просто вызываете нужный метод с путём к файлу.

Аналогично работает Directory:

// Создать папку
Directory.CreateDirectory(@"C:\MyProject\Data");

// Получить все текстовые файлы
string[] textFiles = Directory.GetFiles(@"C:\MyProject", "*.txt");

// Проверить существование папки
if (Directory.Exists(@"C:\Temp"))
{
    Directory.Delete(@"C:\Temp", recursive: true);
}

3. Сравнение подходов на практических примерах

Пример 1: Простое копирование файла

Статический подход:

string sourcePath = "original.txt";
string destinationPath = "copy.txt";

if (File.Exists(sourcePath))
{
    File.Copy(sourcePath, destinationPath, overwrite: true);
    Console.WriteLine("Файл скопирован");
}
else
{
    Console.WriteLine("Исходный файл не найден");
}

Экземплярный подход:

var sourceFile = new FileInfo("original.txt");
var destinationFile = new FileInfo("copy.txt");

if (sourceFile.Exists)
{
    sourceFile.CopyTo(destinationFile.FullName, overwrite: true);
    Console.WriteLine("Файл скопирован");
}
else
{
    Console.WriteLine("Исходный файл не найден");
}

Здесь статический подход лаконичнее. Но что, если нужна дополнительная информация?

Пример 2: Копирование с проверкой размера

Статический подход:

string sourcePath = "largefile.zip";
string destinationPath = "backup.zip";

if (File.Exists(sourcePath))
{
    var fileInfo = new FileInfo(sourcePath); // Всё равно пришлось создать объект!
    if (fileInfo.Length > 100 * 1024 * 1024) // Больше 100 МБ
    {
        Console.WriteLine($"Внимание: копируется большой файл ({fileInfo.Length / 1024 / 1024} МБ)");
    }
    
    File.Copy(sourcePath, destinationPath, overwrite: true);
}

Экземплярный подход:

var sourceFile = new FileInfo("largefile.zip");

if (sourceFile.Exists)
{
    if (sourceFile.Length > 100 * 1024 * 1024) // Больше 100 МБ
    {
        Console.WriteLine($"Внимание: копируется большой файл ({sourceFile.Length / 1024 / 1024} МБ)");
    }
    
    sourceFile.CopyTo("backup.zip", overwrite: true);
}

Здесь объектный подход естественнее: работаем с файлом как с объектом и используем его свойства.

Пример 3: Анализ содержимого папки

Статический подход:

string folderPath = @"C:\Documents";

if (Directory.Exists(folderPath))
{
    string[] files = Directory.GetFiles(folderPath);
    string[] subdirs = Directory.GetDirectories(folderPath);
    
    Console.WriteLine($"Файлов: {files.Length}, Папок: {subdirs.Length}");
    
    // Для получения размеров всё равно нужны FileInfo объекты
    long totalSize = 0;
    foreach (string filePath in files)
    {
        var fileInfo = new FileInfo(filePath);
        totalSize += fileInfo.Length;
    }
    
    Console.WriteLine($"Общий размер: {totalSize / 1024} КБ");
}

Экземплярный подход:

var folder = new DirectoryInfo(@"C:\Documents");

if (folder.Exists)
{
    var files = folder.GetFiles();
    var subdirs = folder.GetDirectories();
    
    Console.WriteLine($"Файлов: {files.Length}, Папок: {subdirs.Length}");
    
    long totalSize = files.Sum(f => f.Length); // Информация уже доступна!
    Console.WriteLine($"Общий размер: {totalSize / 1024} КБ");
}

Здесь DirectoryInfo выигрывает: коллекции FileInfo[] уже содержат метаданные.

4. Критерии выбора подхода

Используйте статические классы (File/Directory), когда:

• Операция простая и одноразовая. Нужно быстро проверить существование файла, удалить его или прочитать содержимое — статические методы идеальны.

// Простое чтение конфигурации
if (File.Exists("config.json"))
{
    string config = File.ReadAllText("config.json");
    // обработка конфигурации...
}

• Не нужна информация о свойствах файла. Если не важны размер, даты или атрибуты — статические вызовы короче и подходят лучше.
• Работаете с путями, а не с файлами как объектами. Когда логика оперирует строковыми путями, статические методы ложатся естественнее.

Используйте экземплярные классы (FileInfo/DirectoryInfo), когда:

• Нужно много информации об одном файле/папке. Свойства вроде Length, CreationTime, Attributes доступны напрямую.

var logFile = new FileInfo("application.log");
Console.WriteLine($"Размер лога: {logFile.Length / 1024} КБ");
Console.WriteLine($"Последнее изменение: {logFile.LastWriteTime}");
Console.WriteLine($"Расположение: {logFile.Directory.FullName}");

• Выполняете множественные операции с одним файлом. Создали объект один раз — используете для разных действий.

var document = new FileInfo("report.docx");
if (document.Exists)
{
    var backup = document.CopyTo($"report_backup_{DateTime.Now:yyyyMMdd}.docx");
    document.MoveTo("archive/report.docx");
    Console.WriteLine($"Документ заархивирован, создана копия {backup.Name}");
}

• Работаете с коллекциями файлов. GetFiles() и GetDirectories() возвращают объекты с полной информацией.
• Нужна объектно-ориентированная архитектура. Файлы/папки как объекты легче передавать, хранить и использовать в LINQ.

5. Особенности производительности и кэширования

Кэширование в экземплярных классах

Одна из ключевых особенностей FileInfo/DirectoryInfo — кэширование метаданных. При первом обращении к свойству (например, Length или CreationTime) .NET делает системный вызов, загружает всю информацию и кэширует её внутри объекта.

var file = new FileInfo("document.txt");

// Первое обращение - системный вызов для загрузки всех метаданных
long size = file.Length;

// Последующие обращения используют кэш - очень быстро
DateTime created = file.CreationTime;
DateTime modified = file.LastWriteTime;
bool readOnly = file.IsReadOnly;

Если нужно несколько свойств одного файла, объектный подход эффективнее: один системный вызов вместо нескольких.

Проблема устаревшего кэша

Оборотная сторона — информация может устареть, если файл изменился вне вашей программы. Используйте Refresh():

var file = new FileInfo("data.txt");
Console.WriteLine($"Размер: {file.Length}"); // Например, 1000 байт

// В это время другая программа изменяет файл...

Console.WriteLine($"Размер: {file.Length}"); // Всё ещё 1000 байт из кэша!

// Принудительное обновление
file.Refresh();
Console.WriteLine($"Размер: {file.Length}"); // Теперь актуальный размер

Статические вызовы всегда идут напрямую к файловой системе, поэтому такой проблемы у них нет.

Массовые операции

На больших наборах файлов выбор API влияет на производительность:

// Статический подход — много системных вызовов
string[] files = Directory.GetFiles(@"C:\Photos");
foreach (string filePath in files)
{
    var info = new FileInfo(filePath); // Системный вызов для каждого файла
    if (info.Length > 10 * 1024 * 1024) // Больше 10 МБ
    {
        Console.WriteLine($"Большое фото: {info.Name}");
    }
}

// Экземплярный подход — один системный вызов на папку
var photosDir = new DirectoryInfo(@"C:\Photos");
foreach (var file in photosDir.GetFiles()) // Информация загружается сразу
{
    if (file.Length > 10 * 1024 * 1024)
    {
        Console.WriteLine($"Большое фото: {file.Name}");
    }
}

6. Различия в API и возможностях

Уникальные возможности экземплярных классов

var file = new FileInfo(@"C:\Projects\MyApp\source\Program.cs");

// Навигация по иерархии папок
DirectoryInfo projectDir = file.Directory.Parent; // MyApp
DirectoryInfo sourceDir = file.Directory; // source

// Детальная информация о файле
Console.WriteLine($"Расширение: {file.Extension}");
Console.WriteLine($"Только для чтения: {file.IsReadOnly}");
Console.WriteLine($"Атрибуты: {file.Attributes}");

// Работа с директорией как объектом
var dir = new DirectoryInfo(@"C:\Projects");
DirectoryInfo parent = dir.Parent; // C:\
DirectoryInfo root = dir.Root;     // C:\

Уникальные возможности статических классов

// Чтение и запись текста одной строкой
string content = File.ReadAllText("config.txt");
File.WriteAllText("output.txt", "Hello World");

// Работа со строками
string[] lines = File.ReadAllLines("data.txt");
File.WriteAllLines("output.txt", new[] { "Line 1", "Line 2" });

// Добавление текста к файлу
File.AppendAllText("log.txt", $"{DateTime.Now}: Application started\n");

// Работа с байтами
byte[] data = File.ReadAllBytes("image.jpg");
File.WriteAllBytes("copy.jpg", data);

7. Практические рекомендации

Сценарий 1: Утилита резервного копирования

Для копирования с проверкой размеров и дат удобнее экземплярные классы:

public void BackupDirectory(string sourcePath, string backupPath)
{
    var sourceDir = new DirectoryInfo(sourcePath);
    var backupDir = new DirectoryInfo(backupPath);
    
    if (!backupDir.Exists)
        backupDir.Create();
    
    foreach (var file in sourceDir.GetFiles())
    {
        var backupFile = new FileInfo(Path.Combine(backupPath, file.Name));
        
        // Копируем только если файл новее или не существует
        if (!backupFile.Exists || file.LastWriteTime > backupFile.LastWriteTime)
        {
            file.CopyTo(backupFile.FullName, overwrite: true);
            Console.WriteLine($"Скопирован: {file.Name} ({file.Length / 1024} КБ)");
        }
    }
}

Сценарий 2: Простая работа с текстовыми файлами

Для загрузки/сохранения простых данных достаточно статических методов:

public void SaveUserPreferences(string username, string theme, bool notifications)
{
    string configPath = "user.config";
    string[] settings = {
        $"Username={username}",
        $"Theme={theme}",
        $"Notifications={notifications}"
    };
    
    File.WriteAllLines(configPath, settings);
}

public Dictionary<string, string> LoadUserPreferences()
{
    string configPath = "user.config";
    var preferences = new Dictionary<string, string>();
    
    if (!File.Exists(configPath))
    {
        // Создаём настройки по умолчанию
        SaveUserPreferences("User", "Light", true);
        return LoadUserPreferences();
    }
    
    string[] lines = File.ReadAllLines(configPath);
    foreach (string line in lines)
    {
        if (line.Contains('='))
        {
            string[] parts = line.Split('=', 2);
            preferences[parts[0]] = parts[1];
        }
    }
    
    return preferences;
}

Сценарий 3: Анализ файловой системы

Для отчётов о дисковом пространстве идеально подходят экземплярные классы:

public void AnalyzeDiskUsage(string path)
{
    var directory = new DirectoryInfo(path);
    var report = new Dictionary<string, long>();
    
    foreach (var file in directory.GetFiles("*", SearchOption.AllDirectories))
    {
        string extension = file.Extension.ToLower();
        if (string.IsNullOrEmpty(extension))
            extension = "(без расширения)";
            
        if (!report.ContainsKey(extension))
            report[extension] = 0;
            
        report[extension] += file.Length;
    }
    
    var sortedReport = report.OrderByDescending(kvp => kvp.Value);
    foreach (var item in sortedReport.Take(10))
    {
        Console.WriteLine($"{item.Key}: {item.Value / 1024 / 1024} МБ");
    }
}

8. Типичные ошибки и подводные камни

Ошибка: Смешивание подходов без необходимости

Иногда начинают со статических методов, а затем создают объекты для метаданных — получается лишнее дублирование обращений:

// Неэффективно - два обращения к файловой системе
if (File.Exists("document.txt"))
{
    var fileInfo = new FileInfo("document.txt"); // Дублирование проверки существования
    Console.WriteLine($"Размер: {fileInfo.Length}");
}

// Лучше сразу использовать объектный подход
var fileInfo = new FileInfo("document.txt");
if (fileInfo.Exists)
{
    Console.WriteLine($"Размер: {fileInfo.Length}");
}

Ошибка: Игнорирование устаревшего кэша

При длительной работе с файлами, которые могут изменяться извне, обновляйте кэш с помощью Refresh():

var logFile = new FileInfo("application.log");

while (true)
{
    logFile.Refresh(); // Обновляем информацию о файле
    
    if (logFile.Length > 100 * 1024 * 1024) // 100 МБ
    {
        // Архивируем лог
        logFile.MoveTo($"logs/archived_{DateTime.Now:yyyyMMdd_HHmmss}.log");
        break;
    }
    
    Thread.Sleep(60000); // Проверяем каждую минуту
}

Ошибка: Неправильный выбор для массовых операций

При обработке тысяч файлов выбор API критичен для производительности:

// Медленно - много мелких обращений к файловой системе
string[] allFiles = Directory.GetFiles(@"C:\BigFolder", "*", SearchOption.AllDirectories);
var largeFiles = allFiles.Where(path => new FileInfo(path).Length > 1024 * 1024).ToList();

// Быстрее - используем готовую информацию
var folder = new DirectoryInfo(@"C:\BigFolder");
var largeFiles = folder.GetFiles("*", SearchOption.AllDirectories)
                      .Where(file => file.Length > 1024 * 1024)
                      .ToList();