CodeGym /Cours /C# SELF /Classes d'instance FileInfo et DirectoryInfo

Classes d'instance FileInfo et DirectoryInfo

C# SELF
Niveau 39, Leçon 1
Disponible

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
Name
Nom du fichier
fileInfo.Name
FullName
Chemin complet
fileInfo.FullName
Length
Taille du fichier en octets
fileInfo.Length
Directory
Répertoire parent (DirectoryInfo)
fileInfo.Directory.FullName
Exists
Le fichier existe-t-il réellement ?
fileInfo.Exists
Extension
Extension du fichier (.txt)
fileInfo.Extension
CreationTime
Date de création
fileInfo.CreationTime
LastWriteTime
Date de la dernière modification
fileInfo.LastWriteTime
IsReadOnly
Lecture seule ?
fileInfo.IsReadOnly
Méthodes
CopyTo()
Copier le fichier
fileInfo.CopyTo("copy.txt")
Delete()
Supprimer le fichier
fileInfo.Delete()
MoveTo()
Déplacer le fichier
fileInfo.MoveTo("move.txt")
OpenRead()
Ouvrir un stream en lecture
using var stream = fileInfo.OpenRead()
OpenWrite()
Ouvrir un stream en écriture
using var stream = fileInfo.OpenWrite()

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
Name
Nom du dossier
dirInfo.Name
FullName
Chemin complet
dirInfo.FullName
Parent
Dossier parent (DirectoryInfo)
dirInfo.Parent.FullName
Exists
Le dossier existe ?
dirInfo.Exists
CreationTime
Date de création
dirInfo.CreationTime
LastWriteTime
Date de modification
dirInfo.LastWriteTime
Méthodes
Create()
Créer le dossier
dirInfo.Create()
Delete()
Supprimer le dossier
dirInfo.Delete()
GetFiles()
Tableau de fichiers (tableau de FileInfo)
dirInfo.GetFiles()
GetDirectories()
Tableau de sous-dossiers (tableau de DirectoryInfo)
dirInfo.GetDirectories()
EnumerateFiles()
Itération des fichiers (retourne IEnumerable<FileInfo>, mode retardé)
dirInfo.EnumerateFiles()
MoveTo()
Déplacer le dossier
dirInfo.MoveTo("path")

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
File.Delete(path)
new FileInfo(path).Delete()
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.

2
Mission
C# SELF, niveau 39, leçon 1
Bloqué
Affichage de la liste des fichiers dans un dossier
Affichage de la liste des fichiers dans un dossier
Commentaires
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION