Obtenir le nième caractère en Swift : comment ne pas faire chuter les performances

Introduction : Pourquoi travailler avec le système de fichiers en C# est nécessaire

Toute application sérieuse sera tôt ou tard confrontée au besoin de sauvegarder des données. Que ce soit des fichiers de configuration, des journaux, des documents utilisateur ou des données temporaires — travailler avec le système de fichiers est une compétence fondamentale pour un développeur C#. Dans cet article, nous allons examiner à l'aide d'exemples pratiques comment créer, lire, écrire et gérer des fichiers et dossiers en utilisant .NET. Vous apprendrez non seulement les opérations de base, mais aussi les bonnes pratiques pour la gestion des exceptions et le travail avec les flux.

Classes principales pour travailler avec le système de fichiers

Dans .NET, les espaces de noms System.IO et System.IO.Enumeration sont utilisés pour interagir avec le système de fichiers. Les principales classes dont vous aurez besoin sont :

\n
• File — méthodes statiques pour créer, copier, supprimer et déplacer des fichiers.
\n
• FileInfo — classe d'instance pour travailler avec un fichier spécifique (prend en charge les mêmes opérations mais nécessite la création d'un objet).
\n
• Directory — méthodes statiques pour travailler avec des répertoires.
\n
• DirectoryInfo — classe d'instance pour travailler avec des répertoires.
\n
• Path — classe utilitaire pour travailler avec les chemins (combinaison, obtention de l'extension, du nom, etc.).
\n
• FileStream — flux de bas niveau pour lire/écrire des octets.
\n
• StreamReader / StreamWriter — wrappers de haut niveau pour travailler avec du texte.
\n

Le choix entre les méthodes statiques et les classes d'instance dépend du scénario. Si vous devez effectuer une seule opération — utilisez File ou Directory. Si plusieurs opérations sont prévues sur le même objet — créez un FileInfo ou DirectoryInfo.

Création, lecture et écriture de fichiers

1. Création et écriture d'un fichier texte

La façon la plus simple d'écrire du texte dans un fichier est d'utiliser la méthode File.WriteAllText. Elle crée le fichier (ou écrase un fichier existant) et ferme le flux automatiquement.

using System.IO;\n\nstring path = @"C:\\temp\\example.txt";\nstring content = "Bonjour le monde ! Ceci est un fichier test.";\n\nFile.WriteAllText(path, content);\nConsole.WriteLine("Fichier créé et écrit.");

Si vous avez besoin d'ajouter des données à la fin d'un fichier, utilisez File.AppendAllText :

File.AppendAllText(path, "\\nLigne ajoutée.");

2. Lecture d'un fichier

Pour lire le texte entier, utilisez File.ReadAllText :

string readContent = File.ReadAllText(path);\nConsole.WriteLine(readContent);

Si le fichier est volumineux, il est préférable de le lire ligne par ligne en utilisant File.ReadLines (retourne IEnumerable<string>) :

foreach (string line in File.ReadLines(path))\n{\n    Console.WriteLine(line);\n}

3. Travail avec les fichiers binaires

Pour les données binaires (images, archives), utilisez FileStream ou BinaryReader/BinaryWriter. Exemple d'écriture d'un tableau d'octets :

byte[] data = { 0x48, 0x65, 0x6C, 0x6C, 0x6F }; // "Hello"\nFile.WriteAllBytes(@"C:\\temp\\binary.dat", data);\n\nbyte[] readData = File.ReadAllBytes(@"C:\\temp\\binary.dat");\nConsole.WriteLine(BitConverter.ToString(readData)); // 48-65-6C-6C-6F

Travail avec les dossiers et la gestion des fichiers

1. Création et suppression de dossiers

Vous pouvez créer un dossier en utilisant Directory.CreateDirectory. La méthode crée tous les dossiers manquants dans le chemin :

string dirPath = @"C:\\temp\\MyApp\\Logs";\nDirectory.CreateDirectory(dirPath);\nConsole.WriteLine("Dossier créé.");

Suppression d'un dossier (de manière récursive, avec tout son contenu) :

if (Directory.Exists(dirPath))\n{\n    Directory.Delete(dirPath, true);\n    Console.WriteLine("Dossier supprimé.");\n}

2. Copie et déplacement de fichiers

Pour copier un fichier, utilisez File.Copy. Le troisième paramètre permet d'écraser un fichier existant :

string sourceFile = @"C:\\temp\\example.txt";\nstring destFile = @"C:\\temp\\backup\\example.txt";\n\nDirectory.CreateDirectory(Path.GetDirectoryName(destFile));\nFile.Copy(sourceFile, destFile, overwrite: true);\nConsole.WriteLine("Fichier copié.");

Pour déplacer un fichier, utilisez File.Move :

string movedFile = @"C:\\temp\\archive\\example.txt";\nDirectory.CreateDirectory(Path.GetDirectoryName(movedFile));\nFile.Move(sourceFile, movedFile);\nConsole.WriteLine("Fichier déplacé.");

Travail avec les chemins

La classe Path fournit des méthodes pratiques pour travailler avec les chemins de fichiers. Exemples :

string fullPath = @"C:\\temp\\MyApp\\Logs\\log.txt";\n\nConsole.WriteLine(Path.GetFileName(fullPath));       // log.txt\nConsole.WriteLine(Path.GetFileNameWithoutExtension(fullPath)); // log\nConsole.WriteLine(Path.GetExtension(fullPath));      // .txt\nConsole.WriteLine(Path.GetDirectoryName(fullPath));  // C:\\temp\\MyApp\\Logs\nConsole.WriteLine(Path.Combine(@"C:\\temp", "MyApp", "Logs", "log.txt")); // C:\\temp\\MyApp\\Logs\\log.txt

Gestion des exceptions

Lors du travail avec le système de fichiers, diverses exceptions peuvent survenir. Les principales sont :

\n
• FileNotFoundException — le fichier n'a pas été trouvé.
\n
• DirectoryNotFoundException — le répertoire n'a pas été trouvé.
\n
• UnauthorizedAccessException — droits d'accès insuffisants.
\n
• IOException — une erreur d'E/S générale (par exemple, le fichier est déjà utilisé).
\n
• PathTooLongException — le chemin dépasse la limite système.
\n

Exemple de gestion des exceptions :

try\n{\n    string content = File.ReadAllText(@"C:\\temp\\missing.txt");\n    Console.WriteLine(content);\n}\ncatch (FileNotFoundException)\n{\n    Console.WriteLine("Fichier non trouvé.");\n}\ncatch (UnauthorizedAccessException)\n{\n    Console.WriteLine("Accès refusé.");\n}\ncatch (IOException ex)\n{\n    Console.WriteLine($"Erreur d'E/S : {ex.Message}");\n}

Travail avec les flux

Pour une gestion plus flexible des fichiers, utilisez les flux. Exemple de lecture d'un fichier en utilisant FileStream et StreamReader :

using (FileStream fs = new FileStream(@"C:\\temp\\example.txt", FileMode.Open, FileAccess.Read))\nusing (StreamReader reader = new StreamReader(fs))\n{\n    string line;\n    while ((line = reader.ReadLine()) != null)\n    {\n        Console.WriteLine(line);\n    }\n}

Exemple d'écriture en utilisant StreamWriter :

using (StreamWriter writer = new StreamWriter(@"C:\\temp\\output.txt", append: false))\n{\n    writer.WriteLine("Première ligne.");\n    writer.WriteLine("Deuxième ligne.");\n}\nConsole.WriteLine("Enregistrement terminé.");

Conclusion

Dans cet article, nous avons couvert les bases du travail avec le système de fichiers en C#. Vous avez appris à créer, lire, écrire des fichiers, gérer des dossiers, travailler avec des chemins et gérer les exceptions. Ces compétences vous seront utiles dans presque tous les projets — des petits utilitaires aux grandes applications d'entreprise. Pour approfondir, je vous recommande d'explorer l'espace de noms System.IO.Compression pour travailler avec les archives et System.IO.MemoryMappedFiles pour un travail efficace avec les gros fichiers.