Docs C# exécutables : Lire et écrire des fichiers

Q: Comment écrire du texte dans un fichier en C# ?

File.WriteAllText("notes.txt", text); crée le fichier, ou l'écrase s'il existe, écrit la chaîne en UTF-8 et le ferme. Utilisez File.WriteAllLines(path, lines) pour une collection de lignes et File.AppendAllText(path, text) pour ajouter à la fin au lieu de remplacer. Les trois se trouvent dans System.IO.

Q: Comment lire un fichier texte en C# ?

string text = File.ReadAllText("notes.txt"); lit tout le fichier en une seule chaîne, et string[] lines = File.ReadAllLines(path); le découpe en lignes. Pour les gros fichiers, utilisez File.ReadLines(path) dans un foreach, qui lit une ligne à la fois au lieu de tout charger, ou un StreamReader.

Q: Comment ajouter du texte à un fichier en C# ?

File.AppendAllText(path, text) ajoute du texte à la fin du fichier et crée le fichier s'il n'existe pas ; File.AppendAllLines(path, lines) fait de même pour des lignes. Avec un flux, ouvrez-le en mode ajout : new StreamWriter(path, append: true). Pensez à ajouter vous-même Environment.NewLine ou \n quand vous ajoutez du texte.

Q: Comment lire un fichier ligne par ligne en C# ?

foreach (string line in File.ReadLines(path)) { ... } lit le fichier une ligne à la fois, donc la mémoire utilisée reste stable même pour des logs de plusieurs gigaoctets. L'équivalent plus ancien est un StreamReader dans un bloc using avec while ((line = reader.ReadLine()) != null). Évitez ReadAllLines pour les gros fichiers : il charge d'abord toutes les lignes dans un tableau.

Q: Comment vérifier qu'un fichier existe en C# ?

File.Exists(path) renvoie true si le fichier existe et que le programme peut le voir, et Directory.Exists(path) fait de même pour les dossiers. Ne comptez pas dessus pour éviter les exceptions : le fichier peut être supprimé ou verrouillé entre la vérification et la lecture, donc gérez quand même FileNotFoundException et IOException autour de l'opération sur le fichier.

Le namespace System.IO contient tout ce qu'il faut pour travailler avec des fichiers. Pour la plupart des tâches, un seul appel sur la classe statique File suffit : il ouvre le fichier, le lit ou l'écrit, et le ferme. Pour les gros fichiers ou un contrôle fin, utilisez StreamReader et StreamWriter. Ajoutez using System.IO; à chaque exemple ci-dessous.

Écrire et lire un fichier entier

File.WriteAllText crée un fichier (ou écrase un fichier existant) avec le texte que vous lui donnez. File.ReadAllText renvoie tout le fichier en une seule chaîne. File.AppendAllText ajoute à la fin :

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string path = "notes.txt";

        File.WriteAllText(path, "Buy coffee\n");           // create or overwrite
        File.AppendAllText(path, "Call the dentist\n");    // add to the end
        File.AppendAllText(path, "Renew passport\n");

        Console.WriteLine(File.Exists(path));
        string text = File.ReadAllText(path);
        Console.Write(text);
        Console.WriteLine($"{text.Length} characters");

        File.WriteAllText(path, "Start over\n");           // replaces everything
        Console.Write(File.ReadAllText(path));

        File.Delete(path);
        Console.WriteLine(File.Exists(path));
    }
}

Sortie :

True
Buy coffee
Call the dentist
Renew passport
43 characters
Start over
False

Un chemin relatif comme "notes.txt" est résolu par rapport au répertoire courant du processus, qui n'est pas toujours le dossier où se trouve votre programme (un service, une tâche planifiée ou un lanceur de tests peut démarrer ailleurs). Pour les fichiers livrés avec votre application, construisez le chemin à partir de AppContext.BaseDirectory.

WriteAllText écrase sans demander. Si perdre l'ancien contenu est gênant, vérifiez d'abord File.Exists ou écrivez dans un fichier temporaire puis mettez-le en place avec File.Move.

Lignes : WriteAllLines, ReadAllLines et ReadLines

Les fichiers d'enregistrements, un par ligne, sont assez courants pour avoir leurs propres méthodes. WriteAllLines écrit chaque chaîne suivie d'un saut de ligne ; ReadAllLines renvoie un string[] :

using System;
using System.IO;
using System.Linq;

class Program
{
    static void Main()
    {
        string path = "sales.csv";
        string[] rows =
        {
            "date,product,amount",
            "2026-03-01,Notebook,4.50",
            "2026-03-01,Pen,1.20",
            "2026-03-02,Backpack,39.90",
        };
        File.WriteAllLines(path, rows);

        string[] lines = File.ReadAllLines(path);
        Console.WriteLine($"{lines.Length} lines, header: {lines[0]}");

        // ReadLines streams: one line at a time, good for big files.
        decimal total = File.ReadLines(path)
            .Skip(1)
            .Select(line => line.Split(','))
            .Sum(cols => decimal.Parse(cols[2], System.Globalization.CultureInfo.InvariantCulture));
        Console.WriteLine($"Total: {total}");

        File.AppendAllLines(path, new[] { "2026-03-03,Stapler,7.00" });
        Console.WriteLine(File.ReadLines(path).Last());
    }
}

Sortie :

4 lines, header: date,product,amount
Total: 45.60
2026-03-03,Stapler,7.00

La différence entre les deux lecteurs compte pour la taille. ReadAllLines lit tout le fichier en mémoire avant de revenir. ReadLines renvoie un IEnumerable<string> paresseux qui lit au fil de l'itération, donc un foreach sur un log de 5 Go n'utilise que quelques kilo-octets. Avec LINQ, ReadLines(...).Where(...).Take(10) arrête de lire une fois qu'il a dix correspondances.

Analyser du CSV avec Split(',') fonctionne pour des fichiers simples que vous avez produits vous-même. Le CSV du monde réel contient des champs entre guillemets qui renferment des virgules ; utilisez pour ceux-là une bibliothèque comme CsvHelper.

Remarquez l'InvariantCulture dans decimal.Parse : sans elle, analyser "4.50" sur une machine réglée en allemand ou en portugais lit le point comme un séparateur de milliers.

StreamWriter et StreamReader

Les méthodes de File ouvrent et ferment le fichier à chaque appel. Pour écrire de nombreux morceaux au fil du temps, ou lire un fichier trop gros pour la mémoire sans LINQ, ouvrez un flux une seule fois. Enveloppez-le toujours dans using pour qu'il soit fermé même si une exception est levée ; un writer non fermé peut ne jamais vider son tampon, et le fichier se retrouve vide ou tronqué.

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string path = "app.log";

        using (var writer = new StreamWriter(path))              // create or overwrite
        {
            writer.WriteLine("INFO  server started");
            writer.WriteLine("WARN  disk 85% full");
            writer.Write("INFO  ");
            writer.WriteLine("request handled in {0} ms", 42);
        }

        using (var writer = new StreamWriter(path, append: true))
        {
            writer.WriteLine("ERROR connection refused");
        }

        using (var reader = new StreamReader(path))
        {
            string line;
            int number = 0;
            while ((line = reader.ReadLine()) != null)
            {
                number++;
                if (!line.StartsWith("INFO"))
                    Console.WriteLine($"{number}: {line}");
            }
        }
    }
}

Sortie :

2: WARN  disk 85% full
4: ERROR connection refused

ReadLine renvoie null à la fin du fichier, ce qui termine la boucle while. Un StreamWriter met sa sortie en tampon et l'écrit sur le disque quand le tampon est plein, quand vous appelez Flush() et quand il est libéré ; le bloc using garantit ce dernier cas.

Depuis C# 8, une déclaration using libère le flux à la fin du bloc englobant, sans les accolades supplémentaires :

using var writer = new StreamWriter(path);   // C# 8: disposed when the method returns
writer.WriteLine("INFO  server started");

Chemins et dossiers

Construisez les chemins avec Path.Combine plutôt que par concaténation de chaînes. Il insère le bon séparateur pour le système d'exploitation (\ sous Windows, / sous Linux et macOS) et ne le double pas. La classe Path décompose aussi les chemins, et Directory crée et liste les dossiers :

using System;
using System.IO;
using System.Linq;

class Program
{
    static void Main()
    {
        string folder = Path.Combine("reports", "2026");
        if (Directory.Exists("reports")) Directory.Delete("reports", recursive: true);
        Directory.CreateDirectory(folder);           // creates "reports" too; no error if it exists

        foreach (var month in new[] { "march", "january", "february" })
            File.WriteAllText(Path.Combine(folder, month + ".txt"), "total: 0");
        File.WriteAllText(Path.Combine(folder, "summary.csv"), "month,total");

        string[] textFiles = Directory.GetFiles(folder, "*.txt")
            .Select(Path.GetFileName)
            .OrderBy(name => name)
            .ToArray();
        Console.WriteLine(string.Join(", ", textFiles));

        string report = Path.Combine(folder, "march.txt");
        Console.WriteLine(Path.GetFileName(report));
        Console.WriteLine(Path.GetFileNameWithoutExtension(report));
        Console.WriteLine(Path.GetExtension(report));
        Console.WriteLine(Path.GetFileName(Path.ChangeExtension(report, ".pdf")));

        Directory.Delete("reports", recursive: true);
        Console.WriteLine(Directory.Exists("reports"));
    }
}

Sortie :

february.txt, january.txt, march.txt
march.txt
march
.txt
march.pdf
False

Un piège : si un argument ultérieur de Path.Combine est un chemin racine (il commence par / ou \, ou par une lettre de lecteur sous Windows), tout ce qui précède est abandonné, donc Path.Combine("reports", "/2026") donne /2026. Passez des parties relatives, ou utilisez Path.Join (.NET Core 3.0 et plus), qui n'abandonne jamais rien.

Directory.GetFiles renvoie les fichiers dans l'ordre fourni par le système de fichiers, qui diffère entre Windows et Linux, donc triez le résultat quand l'ordre compte. Directory.EnumerateFiles est la version paresseuse, dans le même rapport que ReadLines avec ReadAllLines. Passez SearchOption.AllDirectories pour inclure les sous-dossiers.

Gérer les erreurs

Les opérations sur les fichiers échouent pour des raisons extérieures à votre programme : le fichier manque, le dossier n'existe pas, un autre processus l'a ouvert, le disque est plein, les permissions sont incorrectes. Chaque cas a son propre type d'exception. FileNotFoundException et DirectoryNotFoundException dérivent de IOException, donc interceptez-les avant elle ; UnauthorizedAccessException n'en dérive pas, elle a donc besoin de son propre catch :

using System;
using System.IO;

class Program
{
    static string LoadConfig(string path)
    {
        try
        {
            return File.ReadAllText(path);
        }
        catch (FileNotFoundException)
        {
            return "missing file, using defaults";
        }
        catch (DirectoryNotFoundException)
        {
            return "missing folder, using defaults";
        }
        catch (UnauthorizedAccessException)
        {
            return "no permission to read the file";
        }
        catch (IOException e)
        {
            return "could not read the file: " + e.GetType().Name;   // locked, disk error, ...
        }
    }

    static void Main()
    {
        Console.WriteLine(LoadConfig("settings.ini"));
        Console.WriteLine(LoadConfig(Path.Combine("no-such-folder", "settings.ini")));

        File.WriteAllText("settings.ini", "theme=dark");
        Console.WriteLine(LoadConfig("settings.ini"));
        File.Delete("settings.ini");
    }
}

Sortie :

missing file, using defaults
missing folder, using defaults
theme=dark

Un File.Exists avant la lecture semble plus simple, mais il ne dispense pas du try : le fichier peut disparaître, ou être verrouillé par un autre programme, entre la vérification et la lecture. Utilisez Exists pour décider quoi faire, et catch pour survivre à ce qui se passe réellement.

Encodage

File.WriteAllText, WriteAllLines et StreamWriter écrivent par défaut en UTF-8 sans marque d'ordre des octets (BOM), et les lecteurs détectent UTF-8, UTF-16 et UTF-32 à partir d'une BOM si elle est présente. Passez un Encoding quand un fichier doit être dans un format précis :

using System;
using System.IO;
using System.Text;

class Program
{
    static void Main()
    {
        string text = "Café São Paulo";

        File.WriteAllText("plain.txt", text);                     // UTF-8, no BOM
        File.WriteAllText("bom.txt", text, Encoding.UTF8);        // UTF-8 with a 3-byte BOM
        File.WriteAllText("utf16.txt", text, Encoding.Unicode);   // UTF-16 little endian

        foreach (var name in new[] { "plain.txt", "bom.txt", "utf16.txt" })
        {
            long bytes = new FileInfo(name).Length;
            bool same = File.ReadAllText(name) == text;
            Console.WriteLine($"{name,-10} {bytes,3} bytes, reads back unchanged: {same}");
            File.Delete(name);
        }
    }
}

Sortie :

plain.txt   16 bytes, reads back unchanged: True
bom.txt     19 bytes, reads back unchanged: True
utf16.txt   30 bytes, reads back unchanged: True

é et ã occupent deux octets chacun en UTF-8, c'est pourquoi 14 caractères demandent 16 octets, et les trois fichiers se relisent correctement parce que le lecteur reconnaît la BOM. Encoding.UTF8 ressemble à la valeur par défaut mais ajoute une BOM, que certains outils (anciens importateurs CSV, scripts shell) affichent comme des caractères parasites au début de la première ligne ; utilisez new UTF8Encoding(false) pour de l'UTF-8 explicite sans BOM. Lire un fichier dans le mauvais encodage ne lève pas d'exception : cela produit des caractères de remplacement, donc renseignez-vous sur l'encodage d'un fichier que vous n'avez pas créé.

E/S de fichiers asynchrones

Dans les applications web et le code d'interface, bloquer un thread sur des E/S disque le gaspille. .NET Core 2.0 et plus proposent des versions async des méthodes de File :

await File.WriteAllTextAsync("notes.txt", text);
string content = await File.ReadAllTextAsync("notes.txt");
string[] lines = await File.ReadAllLinesAsync("sales.csv");

StreamReader.ReadLineAsync et StreamWriter.WriteLineAsync fonctionnent de la même façon sur les flux.

Erreurs courantes

Ne pas libérer un flux. Sans using, le texte en tampon peut ne jamais atteindre le disque et le fichier reste verrouillé jusqu'au passage du ramasse-miettes.
Construire des chemins avec + "\\" +. Cela casse sous Linux et macOS. Utilisez Path.Combine.
Charger d'énormes fichiers avec ReadAllText ou ReadAllLines. Lisez-les en flux avec ReadLines ou un StreamReader.
Compter sur le répertoire courant. Il dépend de la façon dont le programme a été lancé. Utilisez des chemins absolus ou AppContext.BaseDirectory.
Analyser des nombres venant de fichiers avec la culture de la machine. Passez CultureInfo.InvariantCulture pour les fichiers de données.
S'attendre à ce que File.Exists empêche les exceptions. Le fichier peut changer entre la vérification et l'utilisation.

Questions fréquentes

Comment écrire du texte dans un fichier en C# ?

File.WriteAllText("notes.txt", text); crée le fichier, ou l'écrase s'il existe, écrit la chaîne en UTF-8 et le ferme. Utilisez File.WriteAllLines(path, lines) pour une collection de lignes et File.AppendAllText(path, text) pour ajouter à la fin au lieu de remplacer. Les trois se trouvent dans System.IO.

Comment lire un fichier texte en C# ?

string text = File.ReadAllText("notes.txt"); lit tout le fichier en une seule chaîne, et string[] lines = File.ReadAllLines(path); le découpe en lignes. Pour les gros fichiers, utilisez File.ReadLines(path) dans un foreach, qui lit une ligne à la fois au lieu de tout charger, ou un StreamReader.

Comment ajouter du texte à un fichier en C# ?

File.AppendAllText(path, text) ajoute du texte à la fin du fichier et crée le fichier s'il n'existe pas ; File.AppendAllLines(path, lines) fait de même pour des lignes. Avec un flux, ouvrez-le en mode ajout : new StreamWriter(path, append: true). Pensez à ajouter vous-même Environment.NewLine ou \n quand vous ajoutez du texte.

Comment lire un fichier ligne par ligne en C# ?

foreach (string line in File.ReadLines(path)) { ... } lit le fichier une ligne à la fois, donc la mémoire utilisée reste stable même pour des logs de plusieurs gigaoctets. L'équivalent plus ancien est un StreamReader dans un bloc using avec while ((line = reader.ReadLine()) != null). Évitez ReadAllLines pour les gros fichiers : il charge d'abord toutes les lignes dans un tableau.

Comment vérifier qu'un fichier existe en C# ?

File.Exists(path) renvoie true si le fichier existe et que le programme peut le voir, et Directory.Exists(path) fait de même pour les dossiers. Ne comptez pas dessus pour éviter les exceptions : le fichier peut être supprimé ou verrouillé entre la vérification et la lecture, donc gérez quand même FileNotFoundException et IOException autour de l'opération sur le fichier.

Concepts liés