1. Introduction
En .NET, il existe deux groupes de classes philosophiquement différents pour travailler avec les fichiers et dossiers :
Classes statiques : File, Directory — elles fonctionnent comme un ensemble de fonctions utilitaires : vous appelez une méthode, vous passez un chemin, vous obtenez le résultat.
Classes instance : FileInfo, DirectoryInfo — elles représentent des fichiers et dossiers concrets comme des objets avec leurs propres propriétés et méthodes.
Pourquoi les deux approches ? C'est un compromis entre la simplicité d'utilisation (méthodes statiques) et la flexibilité orientée objet (classes instance). Chacune est pratique dans des scénarios différents.
2. Philosophie des classes statiques
Les classes File et Directory suivent le principe « Fais juste ! ». Elles fournissent une interface directe pour exécuter des opérations sur le système de fichiers sans devoir créer des objets intermédiaires.
// Vérifier l'existence d'un fichier
if (File.Exists("document.txt"))
{
// Lire tout le texte
string content = File.ReadAllText("document.txt");
// Créer une sauvegarde
File.Copy("document.txt", "document_backup.txt");
// Supprimer l'original
File.Delete("document.txt");
}
C'est pratique pour des opérations simples et ponctuelles : pas besoin de penser aux objets, à leur cycle de vie ou état — vous appelez juste la méthode avec le chemin du fichier.
Directory fonctionne de la même façon :
// Créer un dossier
Directory.CreateDirectory(@"C:\MyProject\Data");
// Récupérer tous les fichiers texte
string[] textFiles = Directory.GetFiles(@"C:\MyProject", "*.txt");
// Vérifier l'existence d'un dossier
if (Directory.Exists(@"C:\Temp"))
{
Directory.Delete(@"C:\Temp", recursive: true);
}
3. Comparaison des approches sur des exemples pratiques
Exemple 1 : Copie simple de fichier
Approche statique :
string sourcePath = "original.txt";
string destinationPath = "copy.txt";
if (File.Exists(sourcePath))
{
File.Copy(sourcePath, destinationPath, overwrite: true);
Console.WriteLine("Le fichier a été copié");
}
else
{
Console.WriteLine("Fichier source introuvable");
}
Approche instance :
var sourceFile = new FileInfo("original.txt");
var destinationFile = new FileInfo("copy.txt");
if (sourceFile.Exists)
{
sourceFile.CopyTo(destinationFile.FullName, overwrite: true);
Console.WriteLine("Le fichier a été copié");
}
else
{
Console.WriteLine("Fichier source introuvable");
}
Ici l'approche statique est plus concise. Mais si vous avez besoin d'informations supplémentaires ?
Exemple 2 : Copie avec vérification de la taille
Approche statique :
string sourcePath = "largefile.zip";
string destinationPath = "backup.zip";
if (File.Exists(sourcePath))
{
var fileInfo = new FileInfo(sourcePath); // On a quand même dû créer un objet !
if (fileInfo.Length > 100 * 1024 * 1024) // Plus de 100 Mo
{
Console.WriteLine($"Attention : on copie un gros fichier ({fileInfo.Length / 1024 / 1024} Mo)");
}
File.Copy(sourcePath, destinationPath, overwrite: true);
}
Approche instance :
var sourceFile = new FileInfo("largefile.zip");
if (sourceFile.Exists)
{
if (sourceFile.Length > 100 * 1024 * 1024) // Plus de 100 Mo
{
Console.WriteLine($"Attention : on copie un gros fichier ({sourceFile.Length / 1024 / 1024} Mo)");
}
sourceFile.CopyTo("backup.zip", overwrite: true);
}
L'approche orientée objet est plus naturelle ici : on travaille avec le fichier comme un objet et on utilise ses propriétés.
Exemple 3 : Analyse du contenu d'un dossier
Approche statique :
string folderPath = @"C:\Documents";
if (Directory.Exists(folderPath))
{
string[] files = Directory.GetFiles(folderPath);
string[] subdirs = Directory.GetDirectories(folderPath);
Console.WriteLine($"Fichiers : {files.Length}, Dossiers : {subdirs.Length}");
// Pour obtenir les tailles, on a quand même besoin des objets FileInfo
long totalSize = 0;
foreach (string filePath in files)
{
var fileInfo = new FileInfo(filePath);
totalSize += fileInfo.Length;
}
Console.WriteLine($"Taille totale : {totalSize / 1024} Ko");
}
Approche instance :
var folder = new DirectoryInfo(@"C:\Documents");
if (folder.Exists)
{
var files = folder.GetFiles();
var subdirs = folder.GetDirectories();
Console.WriteLine($"Fichiers : {files.Length}, Dossiers : {subdirs.Length}");
long totalSize = files.Sum(f => f.Length); // L'information est déjà disponible !
Console.WriteLine($"Taille totale : {totalSize / 1024} Ko");
}
Ici DirectoryInfo gagne : les collections FileInfo[] contiennent déjà les métadonnées.
4. Critères de choix de l'approche
Utilisez les classes statiques (File/Directory) quand :
- L'opération est simple et ponctuelle. Besoin de vérifier rapidement l'existence d'un fichier, le supprimer ou lire son contenu — les méthodes statiques sont idéales.
// Lecture simple de configuration
if (File.Exists("config.json"))
{
string config = File.ReadAllText("config.json");
// traitement de la configuration...
}
- Vous n'avez pas besoin des propriétés du fichier. Si la taille, les dates ou les attributs ne sont pas importants — les appels statiques sont plus courts et plus adaptés.
- Vous travaillez avec des chemins plutôt qu'avec des fichiers comme objets. Quand la logique manipule des chaînes de chemin, les méthodes statiques s'intègrent naturellement.
Utilisez les classes instance (FileInfo/DirectoryInfo) quand :
- Vous avez besoin de beaucoup d'informations sur un fichier/dossier. Des propriétés comme Length, CreationTime, Attributes sont accessibles directement.
var logFile = new FileInfo("application.log");
Console.WriteLine($"Taille du log : {logFile.Length / 1024} Ko");
Console.WriteLine($"Dernière modification : {logFile.LastWriteTime}");
Console.WriteLine($"Emplacement : {logFile.Directory.FullName}");
- Vous effectuez de multiples opérations sur un même fichier. Vous créez l'objet une fois et l'utilisez pour différentes actions.
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($"Document archivé, copie créée {backup.Name}");
}
- Vous travaillez avec des collections de fichiers. GetFiles() et GetDirectories() retournent des objets avec toutes les informations.
- Vous avez besoin d'une architecture orientée objet. Les fichiers/dossiers comme objets sont plus faciles à passer, stocker et manipuler avec LINQ.
5. Particularités de performance et caching
Caching dans les classes instance
Une des caractéristiques clés de FileInfo/DirectoryInfo est le caching des métadonnées. Au premier accès à une propriété (par exemple Length ou CreationTime), .NET effectue un appel système, charge toutes les informations et les met en cache dans l'objet.
var file = new FileInfo("document.txt");
// Premier accès - appel système pour charger toutes les métadonnées
long size = file.Length;
// Accès suivants utilisent le cache - très rapide
DateTime created = file.CreationTime;
DateTime modified = file.LastWriteTime;
bool readOnly = file.IsReadOnly;
Si vous avez besoin de plusieurs propriétés d'un même fichier, l'approche orientée objet est plus efficace : un appel système au lieu de plusieurs.
Problème de cache obsolète
L'inconvénient est que l'information peut devenir obsolète si le fichier est modifié en dehors de votre programme. Utilisez Refresh() :
var file = new FileInfo("data.txt");
Console.WriteLine($"Taille : {file.Length}"); // Par exemple, 1000 octets
// Pendant ce temps, une autre application modifie le fichier...
Console.WriteLine($"Taille : {file.Length}"); // Toujours 1000 octets depuis le cache !
// Forcer la mise à jour
file.Refresh();
Console.WriteLine($"Taille : {file.Length}"); // Maintenant la taille est à jour
Les appels statiques vont toujours directement au système de fichiers, donc ils n'ont pas ce problème.
Opérations de masse
Sur de grands ensembles de fichiers, le choix de l'API impacte les performances :
// Approche statique — beaucoup d'appels système
string[] files = Directory.GetFiles(@"C:\Photos");
foreach (string filePath in files)
{
var info = new FileInfo(filePath); // Appel système pour chaque fichier
if (info.Length > 10 * 1024 * 1024) // Plus de 10 Mo
{
Console.WriteLine($"Grande photo : {info.Name}");
}
}
// Approche instance — un appel système par dossier
var photosDir = new DirectoryInfo(@"C:\Photos");
foreach (var file in photosDir.GetFiles()) // Les informations sont chargées d'un coup
{
if (file.Length > 10 * 1024 * 1024)
{
Console.WriteLine($"Grande photo : {file.Name}");
}
}
6. Différences d'API et fonctionnalités
Fonctionnalités uniques des classes instance
var file = new FileInfo(@"C:\Projects\MyApp\source\Program.cs");
// Navigation dans la hiérarchie des dossiers
DirectoryInfo projectDir = file.Directory.Parent; // MyApp
DirectoryInfo sourceDir = file.Directory; // source
// Informations détaillées sur le fichier
Console.WriteLine($"Extension : {file.Extension}");
Console.WriteLine($"Lecture seule : {file.IsReadOnly}");
Console.WriteLine($"Attributs : {file.Attributes}");
// Travailler avec le dossier comme objet
var dir = new DirectoryInfo(@"C:\Projects");
DirectoryInfo parent = dir.Parent; // C:\
DirectoryInfo root = dir.Root; // C:\
Fonctionnalités uniques des classes statiques
// Lire et écrire du texte en une ligne
string content = File.ReadAllText("config.txt");
File.WriteAllText("output.txt", "Hello World");
// Travailler avec des lignes
string[] lines = File.ReadAllLines("data.txt");
File.WriteAllLines("output.txt", new[] { "Line 1", "Line 2" });
// Ajouter du texte au fichier
File.AppendAllText("log.txt", $"{DateTime.Now}: Application started\n");
// Travailler avec des octets
byte[] data = File.ReadAllBytes("image.jpg");
File.WriteAllBytes("copy.jpg", data);
7. Recommandations pratiques
Scénario 1 : Outil de sauvegarde
Pour copier en vérifiant tailles et dates, les classes instance sont plus pratiques :
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));
// Copier seulement si le fichier est plus récent ou n'existe pas
if (!backupFile.Exists || file.LastWriteTime > backupFile.LastWriteTime)
{
file.CopyTo(backupFile.FullName, overwrite: true);
Console.WriteLine($"Copié : {file.Name} ({file.Length / 1024} Ko)");
}
}
}
Scénario 2 : Travail simple avec des fichiers texte
Pour charger/enregistrer des données simples, les méthodes statiques suffisent :
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))
{
// Créer des paramètres par défaut
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;
}
Scénario 3 : Analyse du système de fichiers
Pour des rapports sur l'utilisation du disque, les classes instance sont idéales :
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 = "(sans 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} Mo");
}
}
8. Erreurs typiques et pièges
Erreur : Mélanger les approches sans nécessité
Parfois on commence avec des méthodes statiques, puis on crée des objets pour les métadonnées — ce qui duplique les accès :
// Inefficace - deux accès au système de fichiers
if (File.Exists("document.txt"))
{
var fileInfo = new FileInfo("document.txt"); // Duplication de la vérification d'existence
Console.WriteLine($"Taille : {fileInfo.Length}");
}
// Mieux d'utiliser directement l'approche instance
var fileInfo = new FileInfo("document.txt");
if (fileInfo.Exists)
{
Console.WriteLine($"Taille : {fileInfo.Length}");
}
Erreur : Ignorer le cache obsolète
Quand on travaille longtemps avec des fichiers qui peuvent changer depuis l'extérieur, rafraîchissez le cache avec Refresh() :
var logFile = new FileInfo("application.log");
while (true)
{
logFile.Refresh(); // On met à jour les infos du fichier
if (logFile.Length > 100 * 1024 * 1024) // 100 Mo
{
// On archive le log
logFile.MoveTo($"logs/archived_{DateTime.Now:yyyyMMdd_HHmmss}.log");
break;
}
Thread.Sleep(60000); // On vérifie chaque minute
}
Erreur : Mauvais choix pour les opérations de masse
Quand on traite des milliers de fichiers, le choix de l'API est critique pour les performances :
// Lent - beaucoup de petits accès au système de fichiers
string[] allFiles = Directory.GetFiles(@"C:\BigFolder", "*", SearchOption.AllDirectories);
var largeFiles = allFiles.Where(path => new FileInfo(path).Length > 1024 * 1024).ToList();
// Plus rapide - on utilise les informations déjà prêtes
var folder = new DirectoryInfo(@"C:\BigFolder");
var largeFiles = folder.GetFiles("*", SearchOption.AllDirectories)
.Where(file => file.Length > 1024 * 1024)
.ToList();
GO TO FULL VERSION