1. Introduction
Pourquoi est-il important de vérifier la présence d'un fichier ou d'un dossier ?
Imaginez que vous écrivez un journal, et que votre application prévoit d'ajouter une entrée à la fin du fichier. Tout se passe bien tant que le fichier existe. Mais si le fichier est supprimé par erreur, le programme lèvera une erreur, et toutes vos pensées géniales sur le sens de la vie ou, au pire, sur la météo, disparaîtront sans laisser de trace. De même, si vous voulez créer un nouveau fichier pour ne rien perdre, il vaut mieux s'assurer qu'un tel fichier n'existe pas déjà.
Dans les applications réelles — surtout en développement corporate et industriel — les vérifications préalables de l'existence des fichiers et dossiers permettent d'éviter non seulement des erreurs côté utilisateur et des plantages critiques, mais aussi d'économiser énormément de temps et d'efforts à l'équipe, et, ce qui n'est pas négligeable, d'éviter des maux de tête inutiles.
Travail avec le système de fichiers dans .NET
Sur la plateforme .NET, pour travailler avec les fichiers et dossiers, on utilise principalement les classes suivantes (elles vivent dans l'espace de noms System.IO) :
- File — méthodes statiques pour travailler avec les fichiers : vérifications, copie, suppression, etc.
- Directory — méthodes statiques pour travailler avec les dossiers.
Pour vérifier l'existence, deux méthodes suffisent :
- File.Exists(path) — retourne true si le fichier existe.
- Directory.Exists(path) — retourne true si le dossier existe.
2. Vérification de l'existence du fichier avant ouverture
Exemple concret
Supposons que vous ayez ajouté une fonction pour afficher le contenu du journal :
string diaryPath = "diary.txt";
if (File.Exists(diaryPath))
{
// Le fichier existe, on lit et on affiche le contenu
using var reader = new StreamReader(diaryPath);
string content = reader.ReadToEnd();
Console.WriteLine("Votre journal :\n" + content);
}
else
{
Console.WriteLine("Fichier du journal introuvable !");
// On peut créer directement un nouveau fichier si nécessaire
File.WriteAllText(diaryPath, "Ceci est le début de votre journal.\n");
Console.WriteLine("Nouveau fichier de journal créé.");
}
Dans les projets réels, cette approche est un must-have : vous ne comptez pas sur des « miracles », vous contrôlez la situation vous-même.
3. Vérification de l'existence du fichier avant écriture
Scénario : l'application génère des rapports selon un planning. Il faut que chaque nouveau rapport n'écrase pas le précédent.
Pour ça, il est utile de vérifier : et si le fichier existe déjà ? Si oui — on peut par exemple demander à l'utilisateur de saisir un autre nom ou créer un fichier avec un nom unique.
string reportPath = "report.txt";
if (File.Exists(reportPath))
{
Console.WriteLine($"Le fichier '{reportPath}' existe déjà. Renommez ou supprimez l'ancien fichier.");
}
else
{
using var writer = new StreamWriter(reportPath);
writer.WriteLine("Ceci est le nouveau rapport du jour !");
Console.WriteLine("Fichier de rapport créé avec succès.");
}
Cette vérification évitera à vos utilisateurs (et à vous-même !) des mauvaises surprises comme des fichiers écrasés.
4. Vérification de l'existence du dossier avant écriture
Les fichiers ne résident que rarement à la racine du projet. On les place souvent dans des répertoires dédiés : logs/, reports/, data/, etc. Avant d'écrire un fichier il faut s'assurer que le dossier existe.
string logsDir = "logs";
string logPath = Path.Combine(logsDir, "log.txt"); // Path.Combine aide à concaténer les parties du chemin en toute sécurité
if (!Directory.Exists(logsDir))
{
Console.WriteLine("Dossier 'logs' introuvable. On le crée...");
Directory.CreateDirectory(logsDir);
}
using var writer = new StreamWriter(logPath, append: true);
writer.WriteLine($"[{DateTime.Now}] Application démarrée.");
Console.WriteLine("Écriture dans le fichier de log réussie.");
D'ailleurs, la méthode Directory.CreateDirectory ne lèvera pas d'erreur si le dossier existe déjà — elle l'ignorera simplement, donc la vérification n'est pas obligatoire si ce comportement vous convient.
5. Remarques importantes
Particularités : chemins relatifs et absolus
Une erreur fréquente chez les débutants : confondre chemins relatifs et absolus. Par exemple, si vous faites File.Exists("data.txt"), le programme cherche le fichier dans le dossier de travail courant. Et où est-il ? Cela dépend d'où l'application a été lancée.
Pour être sûr, utilisez des chemins absolus ou construisez le chemin via Path.Combine :
string myDocs = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
string filePath = Path.Combine(myDocs, "myapp", "settings.txt");
Le chemin est toujours explicite, et vous ne perdrez pas de vue le fichier.
Détails importants de la vérification
- Parfois on vérifie l'existence, puis on effectue immédiatement d'autres actions sur le même objet fichier/dossier. Entre le moment où vous appelez File.Exists et la création/suppression qui suit, un autre processus peut avoir modifié l'état. Dans des scénarios critiques, ajoutez la gestion d'erreurs via try-catch.
- Vérifiez non seulement l'existence, mais aussi les droits d'accès. Parfois le fichier existe, mais l'utilisateur n'a pas les permissions nécessaires.
- Pour les répertoires, utilisez Directory.Exists, pas File.Exists — sinon vous obtiendrez toujours false.
- Si le chemin comprend plusieurs répertoires imbriqués, par exemple "data/2024/04", alors Directory.CreateDirectory("data/2024/04") créera toute la chaîne — c'est pratique et évite des vérifications supplémentaires.
Et si on ne vérifie pas ?
Si vous essayez d'ouvrir un fichier inexistant en lecture — vous obtiendrez une FileNotFoundException. Si vous essayez de créer un fichier dans un dossier inexistant — DirectoryNotFoundException. Si le programme tourne sous le compte d'un utilisateur, il verra l'erreur et sera en colère. En production — vous perdez des données/de l'argent/du temps. Donc la « vérification d'existence » n'est pas de l'ennui, c'est une marque de soin pour l'utilisateur (et pour votre tranquillité d'esprit).
GO TO FULL VERSION