1. Introduction
Si les classes statiques comme File et Directory sont comme un couteau suisse universel : toujours sous la main, résolvent rapidement une tâche sans être liées à un objet concret, alors FileInfo et DirectoryInfo sont des outils personnalisés : ils sont créés pour un fichier ou un dossier précis, «connaissent» beaucoup de choses à leur sujet et permettent de travailler de façon plus pratique et flexible, surtout pour des opérations répétées sur le même objet.
Les classes d'instance conservent des détails sur un objet concret du système de fichiers, et après le premier chargement des propriétés il n'est pas nécessaire d'aller de nouveau dans le système de fichiers pour obtenir les infos (sauf si l'objet est devenu obsolète).
- FileInfo — pour travailler avec un fichier concret.
- DirectoryInfo — pour travailler avec un répertoire (dossier) concret.
Ils contiennent des propriétés et des méthodes qui permettent d'obtenir des informations détaillées (taille, date de création, extension, attributs disponibles) et d'effectuer des actions sur le fichier/dossier : copier, supprimer, déplacer, etc.
Comment sont organisés FileInfo et DirectoryInfo
Les deux classes héritent d'une classe abstraite commune FileSystemInfo, ce qui permet d'écrire du code qui travaille à la fois avec des fichiers et des dossiers.
System.Object
|
System.MarshalByRefObject
|
System.IO.FileSystemInfo (classe abstraite)
| |
FileInfo DirectoryInfo
Quand utiliser les classes d'instance ?
- Si vous avez besoin de beaucoup d'informations sur un même fichier/dossier (taille, date de modification, extension, attributs, etc.) et que ces données sont réutilisées plusieurs fois.
- Si vous voulez itérer tous les fichiers/dossiers dans un répertoire et traiter chaque objet comme une instance «vivante».
- Pour optimiser quand il est important de ne pas interroger le système de fichiers inutilement (caching des infos).
- Pour un style de code plus orienté objet (backups, médiathèque, gestionnaire de fichiers, etc.).
Comment créer une instance de FileInfo ou DirectoryInfo
using System.IO;
// Création d'un objet FileInfo pour un fichier existant (ou non !) :
var fileInfo = new FileInfo("notes.txt");
// Création d'un objet DirectoryInfo pour un dossier :
var dirInfo = new DirectoryInfo(@"C:\Projects");
// On peut utiliser des chemins relatifs ou absolus !
Important : créer un objet FileInfo ou DirectoryInfo NE crée PAS le fichier/le dossier dans le système de fichiers ! C'est juste une description (un lien).
2. Travailler avec FileInfo
Voyons les principales propriétés et méthodes de cette classe. Petit mémo :
| Propriété/méthode | Que retourne ? | Exemple d'utilisation |
|---|---|---|
|
Nom du fichier | |
|
Chemin complet | |
|
Taille du fichier en octets | |
|
Répertoire parent (DirectoryInfo) | |
|
Le fichier existe-t-il réellement ? | |
|
Extension du fichier (.txt) | |
|
Date de création | |
|
Date de la dernière modification | |
|
Lecture seule ? | |
| Méthodes | ||
|
Copier le fichier | |
|
Supprimer le fichier | |
|
Déplacer le fichier | |
|
Ouvrir un stream en lecture | |
|
Ouvrir un stream en écriture | |
Exemple : Informations sur un fichier
Ajoutons un petit module qui récupère des informations détaillées sur un fichier en utilisant FileInfo.
Console.WriteLine("Entrez le nom du fichier :");
string fileName = Console.ReadLine();
var file = new FileInfo(fileName);
if (file.Exists)
{
Console.WriteLine($"Nom du fichier : {file.Name}");
Console.WriteLine($"Chemin : {file.FullName}");
Console.WriteLine($"Taille : {file.Length} octets");
Console.WriteLine($"Extension : {file.Extension}");
Console.WriteLine($"Date de création : {file.CreationTime}");
Console.WriteLine($"Dernière modification : {file.LastWriteTime}");
// En plus : afficher le répertoire parent
Console.WriteLine($"Dossier parent : {file.DirectoryName}");
}
else
{
Console.WriteLine("Fichier introuvable.");
}
Remarque : on ne lit pas le contenu du fichier, on récupère juste la méta-information.
Pratique : Copier et supprimer un fichier
// ... Dans la méthode principale après l'affichage des infos sur le fichier :
Console.WriteLine("Entrez le chemin pour la copie du fichier :");
string copyPath = Console.ReadLine();
try
{
file.CopyTo(copyPath);
Console.WriteLine($"Fichier copié avec succès vers {copyPath}");
}
catch (IOException ex)
{
Console.WriteLine($"Impossible de copier le fichier : {ex.Message}");
}
// Maintenant on supprime la copie
Console.WriteLine("Supprimer la copie du fichier ? (y/n) :");
if (Console.ReadLine().Trim().ToLower() == "y")
{
var copyFile = new FileInfo(copyPath);
if (copyFile.Exists)
{
copyFile.Delete();
Console.WriteLine("La copie a été supprimée.");
}
}
3. Travailler avec DirectoryInfo
Voyons ce que DirectoryInfo nous offre :
| Propriété/méthode | Que retourne ? | Exemple d'utilisation |
|---|---|---|
|
Nom du dossier | |
|
Chemin complet | |
|
Dossier parent (DirectoryInfo) | |
|
Le dossier existe ? | |
|
Date de création | |
|
Date de modification | |
| Méthodes | ||
|
Créer le dossier | |
|
Supprimer le dossier | |
|
Tableau de fichiers (tableau de FileInfo) | |
|
Tableau de sous-dossiers (tableau de DirectoryInfo) | |
|
Itération des fichiers (retourne IEnumerable<FileInfo>, mode retardé) | |
|
Déplacer le dossier | |
Exemple : Parcourir fichiers et dossiers
Console.WriteLine("Entrez le chemin du dossier :");
string path = Console.ReadLine();
var dir = new DirectoryInfo(path);
if (!dir.Exists)
{
Console.WriteLine("Dossier introuvable !");
return;
}
Console.WriteLine("\n--- Fichiers ---");
foreach (var file in dir.GetFiles())
{
Console.WriteLine($"{file.Name} ({file.Length} octets)");
}
Console.WriteLine("\n--- Sous-dossiers ---");
foreach (var subDir in dir.GetDirectories())
{
Console.WriteLine(subDir.Name);
}
4. Nuances utiles
Méthodes statiques vs classes d'instance
Quand utiliser quelle approche ? Si vous faites une action rapide «one-off» — par exemple File.Exists(path) ou File.ReadAllText(path) — les méthodes statiques sont souvent les plus adaptées. Elles sont simples et un peu plus rapides grâce à des frais généraux minimaux.
Si par contre vous voulez obtenir beaucoup d'informations sur un fichier ou dossier, exécuter des opérations répétées sur cet objet, ou écrire du code en style OOP, mieux vaut utiliser les instances FileInfo et DirectoryInfo.
Il est intéressant de noter que les deux approches utilisent sous le capot des appels systèmes similaires. Mais les classes d'instance mettent en cache certaines propriétés (taille, date, attributs), réduisant le nombre d'accès au système de fichiers — très pratique quand on parcourt un grand nombre de fichiers.
Un mot sur la gestion des dates et heures
Les propriétés CreationTime, LastWriteTime, LastAccessTime retournent des valeurs de type DateTime.
Console.WriteLine($"Fichier créé : {file.CreationTime:yyyy-MM-dd HH:mm:ss}");
Console.WriteLine($"Dernière modification : {file.LastWriteTime:yyyy-MM-dd HH:mm:ss}");
Si un fichier ou dossier a été modifié sur le disque après que vous ayez obtenu l'objet FileInfo ou DirectoryInfo, les informations en cache peuvent être obsolètes. Pour les rafraîchir, appelez file.Refresh().
Conseils et remarques pratiques
- Les classes d'instance sont pratiques quand vous construisez une couche autour du système de fichiers : backups, médiathèque, indexeur.
- Elles fonctionnent très bien avec LINQ : vous pouvez filtrer par taille, date ou extension puis effectuer des opérations sur les éléments sélectionnés.
- Pour les opérations en masse il est préférable d'utiliser EnumerateFiles() et EnumerateDirectories() plutôt que GetFiles()/GetDirectories() — l'énumération lazy économise la mémoire et accélère le démarrage du traitement.
Comparaison approche statique vs instance
| Méthodes statiques | Classes d'instance | |
|---|---|---|
| Syntaxe | |
|
| Cache | Non | Oui |
| Beaucoup d'informations | Il faut appeler plusieurs méthodes | Les infos sont dans l'objet |
| Style OOP | Non | Oui |
| Opérations en masse | Peu pratique | Pratique |
| Travail avec des streams | Oui | Oui |
Rafraîchir les informations et objets
Les objets FileInfo/DirectoryInfo mettent en cache des valeurs après le premier accès aux propriétés. Si l'objet (fichier ou dossier) a été modifié sur le disque après la création de l'instance, pour rafraîchir l'information appelez la méthode .Refresh().
var file = new FileInfo("notes.txt");
long oldSize = file.Length;
// Pendant ce temps quelqu'un (ou vous) modifie le fichier en dehors du programme
file.Refresh();
long newSize = file.Length;
Cela n'arrive pas souvent, mais si votre programme surveille le système de fichiers — ce mécanisme est important.
5. Erreurs typiques en travaillant avec des classes d'instance
Idée reçue : si on crée l'objet new FileInfo("file.txt"), alors le fichier existe déjà. En réalité ce n'est pas le cas — le fichier n'apparaît qu'après une écriture explicite ou l'appel de Create().
Tenter d'accéder aux propriétés d'un fichier qui n'existe pas : certaines propriétés renverront des valeurs par défaut (par exemple la taille 0), mais essayer d'ouvrir un stream en lecture déclenchera une exception.
Pour les dossiers c'est la même chose : créer une DirectoryInfo ne garantit pas que le dossier existe sur le disque avant d'appeler Create() ou qu'il apparaisse réellement.
GO TO FULL VERSION