Création et suppression de fichiers

1. Introduction

On pourrait penser qu'un fichier est une chose simple, et le créer est un jeu d'enfant : il suffit de cliquer droit (sous Windows). Mais dans les vrais projets, la création et la suppression programmatiques de fichiers sont la clé de l'automatisation et de la flexibilité. Par exemple :

• Dans un éditeur de texte, l'utilisateur appuie sur « Enregistrer » — et votre code crée un nouveau fichier où il écrira le travail de l'auteur.
• Un service de logging crée automatiquement des fichiers de logs au démarrage de l'application.
• Un utilitaire d'archivage ou de backup crée régulièrement des fichiers temporaires puis les supprime.
• Une application de jeu en C# fait des autosaves — elle crée ou écrase le fichier de sauvegarde.
• Et vous (ou votre script) nettoyez automatiquement un dossier des anciens fichiers temporaires pour ne pas encombrer le disque.

Savoir créer et supprimer des fichiers automatiquement est une compétence fondamentale pour un développeur .NET moderne.

2. Opérations rapides via File

Créer un fichier

En C#, il existe plusieurs façons de créer un fichier. Le moyen le plus rapide et simple est d'utiliser la classe statique File. Essayons :

// Créons un fichier vide "myfile.txt" dans le répertoire courant
File.Create("myfile.txt").Close(); // Il faut fermer le FileStream !
Console.WriteLine("Le fichier 'myfile.txt' a été créé.");

Remarque importante :
La méthode File.Create retourne un objet FileStream qu'il faut fermer (Close()) pour éviter que l'OS se plaigne que le fichier est « occupé ». Sans cette fermeture, d'autres opérations sur le même fichier peuvent échouer de manière inattendue. Classique : "Le fichier est utilisé par un autre processus", alors que ce « autre processus » est encore votre propre programme qui n'a pas fermé le flux.

Si le fichier existait déjà, File.Create l'écrasera (l'ancien est supprimé, un nouveau vide est créé). Sinon, le fichier sera créé.

Et à quoi sert un fichier vide ?

Le plus souvent, on veut écrire quelque chose dans le nouveau fichier. Pour ça il existe des méthodes pratiques :

File.WriteAllText("welcome.txt", "Privet, mir fajlov!");

Cette commande créera le fichier, y écrira la chaîne, et fermera proprement la porte (le fichier) pour éviter les problèmes.

Vérifier l'existence d'un fichier

Avant de créer un nouveau fichier, il est utile de vérifier s'il n'existe pas déjà. Sinon on risque d'effacer quelque chose d'important.

if (!File.Exists("important.txt"))
{
    File.WriteAllText("important.txt", "Sohranjaem vazhnuju informaciju.");
    Console.WriteLine("Fajl sozdán.");
}
else
{
    Console.WriteLine("Un tel fichier existe déjà, on peut imaginer autre chose !");
}

3. Exemple concret : "On sauvegarde le message de bienvenue de l'utilisateur"

Console.Write("Vvedite vashe imja: ");
string name = Console.ReadLine();

string filename = $"{name}_greeting.txt";
string message = $"Dobro pozhalovat', {name}!";

// Vérifions si le fichier existe
if (!File.Exists(filename))
{
    File.WriteAllText(filename, message);
    Console.WriteLine($"Le fichier de bienvenue personnalisé {filename} a été créé.");
}
else
{
    Console.WriteLine($"Le fichier {filename} existe déjà ! Écraser ? (y/n)");
    string answer = Console.ReadLine();
    if (answer?.ToLower() == "y")
    {
        File.WriteAllText(filename, message);
        Console.WriteLine($"Le fichier {filename} a été écrasé.");
    }
    else
    {
        Console.WriteLine("On laisse tout comme c'était.");
    }
}

Ce qu'on fait ici :

• On vérifie si le fichier existe (File.Exists).
• Si non — on le crée et écrit du texte (File.WriteAllText).
• Si oui — on demande à l'utilisateur s'il faut écraser.

4. Suppression d'un fichier

Supprimer des fichiers en C# est presque hacker... mais sûr ! C'est aussi simple :

Utiliser File.Delete

File.Delete("myfile.txt");

Si le fichier n'existe pas — pas de drame ! Rien ne se passera (aucune erreur si le chemin est correct).

Pièges pour les débutants

• Si le fichier est déjà ouvert par votre programme (ou un autre), une exception sera levée.
• Si le chemin est incorrect — une ArgumentException apparaîtra.

Recommandation : toujours vérifier l'existence

if (File.Exists("victim.txt"))
{
    File.Delete("victim.txt");
    Console.WriteLine("Fichier supprimé.");
}
else
{
    Console.WriteLine("Rien à supprimer — ce fichier n'a pas été trouvé.");
}

5. Dossiers et fichiers : créer une structure de fichiers

Créer un fichier dans un dossier

string folder = "Data";
Directory.CreateDirectory(folder); // si le dossier n'existe pas — il sera créé

string filename = Path.Combine(folder, "info.txt");
File.WriteAllText(filename, "Zdes' hranitsja sekretnoe poslanie!");

Important : Si vous essayez de créer un fichier dans un dossier inexistant, une exception sera levée. Donc appelez d'abord Directory.CreateDirectory(folder). Elle ne recréera pas le dossier s'il existe déjà, donc l'appel est sûr.

6. Travailler avec des instances : FileInfo

Pour des scénarios un peu plus "old-school" et avancés, la classe FileInfo est utile :

FileInfo fi = new FileInfo("example.txt");

// Créer un nouveau fichier (comme File.Create — crée un fichier vide)
using (var fs = fi.Create())
{
    // on peut écrire quelque chose si on veut
}

Console.WriteLine($"Le fichier 'example.txt' a été créé via FileInfo.");

Suppression via FileInfo :

FileInfo fi = new FileInfo("oldfile.txt");
if (fi.Exists)
{
    fi.Delete();
    Console.WriteLine("Fichier supprimé via FileInfo.");
}

Avantages de FileInfo

Si vous comptez faire plus que juste créer/supprimer — accéder souvent aux propriétés du fichier ou effectuer plusieurs opérations — l'approche par instance est plus pratique (et parfois plus performante).

7. Créons et nettoyons des "fichiers techniques"

Supposons que l'application accumule des fichiers temporaires dans le dossier "temp_data", et qu'on veuille supprimer tous les fichiers dont le nom commence par "temp_".

string tempFolder = "temp_data";
Directory.CreateDirectory(tempFolder);

for (int i = 1; i <= 5; i++)
{
    string tempFile = Path.Combine(tempFolder, $"temp_{i}.txt");
    File.WriteAllText(tempFile, $"Testovye dannye {i}");
}
Console.WriteLine("5 fichiers temporaires créés.");

// Maintenant supprimons tous les temp_*.txt
foreach (string file in Directory.GetFiles(tempFolder, "temp_*.txt"))
{
    File.Delete(file);
    Console.WriteLine($"Fichier supprimé : {file}");
}

Très pratique pour nettoyer automatiquement les fichiers anciens et temporaires.

8. Détails importants : exceptions et sécurité

Ce qui peut mal tourner :

• Pas de droits d'écriture/suppression dans le dossier (par exemple, C:\Windows)
• Le fichier est déjà utilisé par un autre programme (ou le vôtre !)
• Le chemin contient des caractères interdits (par exemple, *?<>)
• Le fichier est supprimé par un autre processus entre votre vérification et la suppression (oui, ça arrive!)

Comment se protéger

Dans du code de production, entourez toujours ces opérations d'un bloc try-catch :

try
{
    File.Delete("trickyfile.txt");
    Console.WriteLine("Fichier supprimé.");
}
catch (UnauthorizedAccessException ex)
{
    Console.WriteLine("Pas les droits pour supprimer le fichier.");
}
catch (IOException ex)
{
    Console.WriteLine("Le fichier peut être utilisé par un autre processus.");
}
catch (Exception ex)
{
    Console.WriteLine($"Erreur : {ex.Message}");
}

9. Astuces utiles

Fichiers toujours sous contrôle

• Utilisez Path.Combine pour construire les chemins. Ainsi vous évitez les problèmes de slash manquant ou en trop, et votre code restera cross-platform.
• Vérifiez l'existence du fichier avant création/suppression si vous ne voulez pas de surprises.
• Entourez votre code d'un try-catch si vous travaillez en production et surtout dans une application multi-utilisateur.
• Pour des opérations fréquentes sur le même fichier utilisez FileInfo, pour une opération ponctuelle — File.
• Ne gardez pas les fichiers ouverts plus longtemps que nécessaire. Fichier ouvert ? Demandez-vous : "Et pourquoi ?" et fermez-le ! Utilisez using quand c'est possible.

Fiche technique

File.Create

File.WriteAllText

File.Exists

File.Delete

Directory.CreateDirectory + File.WriteAllText

new FileInfo(path).Create / Delete / Exists

10. Erreurs typiques quand on travaille avec des fichiers

Erreur n°1 : on oublie de fermer le flux retourné par File.Create.
Beaucoup de débutants créent un fichier avec File.Create mais n'en ferment pas le flux retourné. Résultat : le reste du code cesse de « voir » le fichier — comme s'il était dans un univers parallèle. Fermez explicitement le flux (Close()) ou utilisez la construction using.

Erreur n°2 : on essaie de créer un fichier dans un dossier qui n'existe pas.
Piège courant : essayer de créer un fichier dans un répertoire qui n'existe pas encore. N'oubliez pas d'appeler Directory.CreateDirectory en amont. C'est totalement sûr : rien de superflu ne sera créé, et le dossier nécessaire apparaîtra.

Erreur n°3 : on supprime un fichier sans vérifier.
Parfois on veut juste appeler File.Delete sans vérifier l'existence. C'est acceptable — la méthode ne lèvera pas d'erreur si le fichier n'existe pas. Mais si le chemin est incorrect ou s'il n'y a pas d'accès — l'exception est garantie. Mieux vaut la gérer.

Erreur n°4 : on confond File.Delete et Directory.Delete.
File.Delete fonctionne uniquement pour les fichiers, et Directory.Delete pour les dossiers. Essayer de supprimer un dossier avec File.Delete revient à essayer de polir une brique avec une brosse à dents : techniquement possible, mais pas très logique.