Fichier système Mastering C#

Introduction

En C#, l'espace de noms System.IO fournit des classes puissantes pour interagir avec le système de fichiers. Ces classes, telles que File, FileInfo, Directory et DirectoryInfo, vous permettent d'effectuer diverses opérations sur les fichiers, comme créer des fichiers, lire des données, écrire dans des fichiers, et vérifier si un fichier spécifié existe déjà dans un chemin spécifié. Grâce à ces classes, vous pouvez travailler avec des fichiers texte, des fichiers binaires et des fichiers d'extensions diverses. Des méthodes comme Create(), Exists() et Delete() permettent aux développeurs de gérer efficacement les fichiers et les répertoires.

Par exemple, la classe File inclut des méthodes statiques pour vérifier si un fichier existe déjà, créer un nouveau fichier, ou ouvrir des fichiers dans différents modes (comme lecture, écriture ou ajout). Vous pouvez également utiliser la classe FileInfo pour obtenir plus de détails sur un fichier, comme son heure de création ou son chemin complet. La classe DirectoryInfo vous permet de travailler avec des répertoires, obtenir des fichiers, ou créer de nouveaux répertoires. Ces classes et méthodes offrent la flexibilité nécessaire pour traiter à la fois les fichiers existants et les nouveaux fichiers, gérer plusieurs fichiers et même traiter les données de fichiers au niveau de l'octet, ce qui fait de C# un outil puissant pour les opérations de système de fichiers.

Tim commence par mettre en avant les puissantes fonctionnalités de C# pour l'automatisation des tâches liées aux fichiers, telles que la création de sauvegardes, l'organisation de fichiers et la récupération d'informations sur les fichiers. Il introduit la vidéo en déclarant son objectif de faciliter l'apprentissage du C# grâce à des exemples pratiques et des ressources de formation.

Création d'une application console de démonstration

Tim part de zéro, en créant une nouvelle application console nommée "FileSystemDemo" à l'aide du .NET Framework. Il insiste sur le choix du .NET Framework par rapport à .NET Core pour cette démonstration.

using System;
using System.IO;

namespace FileSystemDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.ReadLine();
        }
    }
}

using System;
using System.IO;

namespace FileSystemDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.ReadLine();
        }
    }
}

Mise en place du chemin racine

Tim met en place une variable de chemin d'accès racine pointant vers un répertoire spécifique de son système pour la démo.

string rootPath = @"C:\temp\demos\filesystem";

string rootPath = @"C:\temp\demos\filesystem";

Il explique que le symbole @ permet l'utilisation de barres obliques inverses dans le chemin sans avoir besoin de les échapper.

Lecture de tous les répertoires dans le chemin

Tim démontre comment récupérer tous les répertoires dans le chemin racine spécifié en utilisant la méthode Directory.GetDirectories.

string[] directories = Directory.GetDirectories(rootPath);
foreach (string directory in directories)
{
    Console.WriteLine(directory);
}

string[] directories = Directory.GetDirectories(rootPath);
foreach (string directory in directories)
{
    Console.WriteLine(directory);
}

Ce code imprime les chemins d'accès complets de tous les sous-répertoires du répertoire racine.

Lecture récursive de sous-répertoires

Pour inclure les sous-répertoires dans la recherche, Tim ajoute un motif de recherche et des options de recherche à la méthode GetDirectories.

string[] allDirectories = Directory.GetDirectories(rootPath, "*", SearchOption.AllDirectories);
foreach (string directory in allDirectories)
{
    Console.WriteLine(directory);
}

string[] allDirectories = Directory.GetDirectories(rootPath, "*", SearchOption.AllDirectories);
foreach (string directory in allDirectories)
{
    Console.WriteLine(directory);
}

Cette modification garantit que tous les sous-répertoires imbriqués sont inclus dans la recherche.

Lecture de tous les fichiers dans le chemin

Tim montre comment récupérer tous les fichiers dans la classe de répertoires et le chemin racine spécifié en utilisant la méthode Directory.GetFiles.

string[] files = Directory.GetFiles(rootPath, "*.*", SearchOption.AllDirectories);
foreach (string file in files)
{
    Console.WriteLine(file);
}

string[] files = Directory.GetFiles(rootPath, "*.*", SearchOption.AllDirectories);
foreach (string file in files)
{
    Console.WriteLine(file);
}

Ce code imprime les chemins d'accès complets de tous les fichiers du répertoire racine et de ses sous-répertoires.

Extraction de noms de fichiers et de chemins

Tim explique comment extraire les noms et les chemins de fichiers en utilisant la classe Path. Il s'agit notamment d'obtenir le nom du fichier sans son extension et le nom du répertoire de chaque fichier.

foreach (string file in files)
{
    Console.WriteLine(Path.GetFileName(file)); // File name with extension
    Console.WriteLine(Path.GetFileNameWithoutExtension(file)); // File name without extension
    Console.WriteLine(Path.GetDirectoryName(file)); // Directory name
}

foreach (string file in files)
{
    Console.WriteLine(Path.GetFileName(file)); // File name with extension
    Console.WriteLine(Path.GetFileNameWithoutExtension(file)); // File name without extension
    Console.WriteLine(Path.GetDirectoryName(file)); // Directory name
}

Cet extrait de code montre comment extraire et imprimer différentes parties d'un même fichier dans le chemin spécifié.

Récupération d'informations sur les fichiers

Tim à (12:10) démontre comment récupérer des informations détaillées sur un fichier en utilisant la classe FileInfo. Il s'agit notamment d'obtenir la taille du fichier, la date du dernier accès, la date de création et d'autres attributs.

foreach (string file in files)
{
    FileInfo info = new FileInfo(file);
    Console.WriteLine($"{Path.GetFileName(file)}: {info.Length} bytes");
}

foreach (string file in files)
{
    FileInfo info = new FileInfo(file);
    Console.WriteLine($"{Path.GetFileName(file)}: {info.Length} bytes");
}

Cet extrait de code imprime le nom du fichier et sa taille en octets. Tim indique que vous pouvez convertir cette taille en kilo-octets ou en méga-octets en divisant par 1024 à plusieurs reprises.

Il explique en outre que la classe FileInfo fournit d'autres propriétés utiles :

• LastWriteTime : La dernière fois que le fichier a été modifié.

• LastAccessTime : La dernière fois que le fichier a été consulté.

• CreationTime : Le temps de création du fichier.

• Attributes : Les attributs de fichier, tels que lecture seule ou archive.

Automating File System Tasks with C

Tim, à (15:11), explique comment utiliser C# pour automatiser diverses tâches liées au système de fichiers. Il peut s'agir de créer des répertoires, de vérifier l'existence de fichiers ou de répertoires et d'autres tâches répétitives.

Vérifier l'existence d'un répertoire

Tim montre comment vérifier si un répertoire existe en utilisant la méthode Directory.Exists. Cela permet de s'assurer que les répertoires nécessaires sont en place avant d'effectuer des opérations.

string newPath = @"C:\temp\demos\filesystem\subfolderC";
if (Directory.Exists(newPath))
{
    Console.WriteLine("Directory exists");
}
else
{
    Console.WriteLine("Directory does not exist");
}

string newPath = @"C:\temp\demos\filesystem\subfolderC";
if (Directory.Exists(newPath))
{
    Console.WriteLine("Directory exists");
}
else
{
    Console.WriteLine("Directory does not exist");
}

Ce code vérifie l'existence d'un répertoire et imprime un message approprié.

Création d'un nouveau répertoire

Tim explique comment créer un nouveau répertoire en utilisant la méthode Directory.CreateDirectory. Cette méthode crée tous les répertoires et sous-répertoires du chemin spécifié s'ils n'existent pas déjà.

string newPath = @"C:\temp\demos\filesystem\subfolderC\sub-subfolderD";
Directory.CreateDirectory(newPath);
Console.WriteLine("Directories created");

string newPath = @"C:\temp\demos\filesystem\subfolderC\sub-subfolderD";
Directory.CreateDirectory(newPath);
Console.WriteLine("Directories created");

Tim démontre que cette méthode crée le chemin spécifié et ses sous-répertoires sans écraser les fichiers ou répertoires existants.

Copier des fichiers

Tim à (21:35) démontre comment copier des fichiers d'un répertoire à un autre en utilisant la méthode File.Copy. Ces outils peuvent être utiles pour sauvegarder des fichiers ou les organiser dans différents dossiers.

string[] files = Directory.GetFiles(rootPath);
string destinationFolder = Path.Combine(rootPath, "subfolderA");

foreach (string file in files)
{
    string destFile = Path.Combine(destinationFolder, Path.GetFileName(file));
    File.Copy(file, destFile, true);
}

string[] files = Directory.GetFiles(rootPath);
string destinationFolder = Path.Combine(rootPath, "subfolderA");

foreach (string file in files)
{
    string destFile = Path.Combine(destinationFolder, Path.GetFileName(file));
    File.Copy(file, destFile, true);
}

Dans cet exemple, les fichiers sont copiés du répertoire racine à subfolderA, et les fichiers existants sont écrasés en raison du paramètre true.

Renommer les fichiers pendant la copie

Tim montre également comment renommer des fichiers pendant le processus de copie en utilisant une boucle for avec un index.

for (int i = 0; i < files.Length; i++)
{
    string destFile = Path.Combine(destinationFolder, $"{i}.txt");
    File.Copy(files[i], destFile, true);
}

for (int i = 0; i < files.Length; i++)
{
    string destFile = Path.Combine(destinationFolder, $"{i}.txt");
    File.Copy(files[i], destFile, true);
}

Ce code copie les fichiers vers le répertoire de destination et les renomme séquentiellement en 0.txt, 1.txt, etc.

Gestion des écrasements de fichiers

Tim explique comment manipuler les fichiers existants sans écrasement et éviter les exceptions en réglant le paramètre d'écrasement à false. Cela empêche les fichiers existants d'être écrasés et lance une exception si un fichier existe déjà.

try
{
    File.Copy(sourceFile, destFile, false);
}
catch (IOException ex)
{
    Console.WriteLine($"File already exists: {ex.Message}");
}

try
{
    File.Copy(sourceFile, destFile, false);
}
catch (IOException ex)
{
    Console.WriteLine($"File already exists: {ex.Message}");
}

Cette approche permet de gérer en toute sécurité les copies de fichiers et les situations dans lesquelles les fichiers ne doivent pas être écrasés.

Déplacement de fichiers

Tim à (28:28) démontre comment déplacer des fichiers en utilisant la méthode File.Move. Contrairement à File.Copy, la méthode File.Move n'a pas d'option d'écrasement et générera une exception si le fichier de destination existe déjà.

string[] files = Directory.GetFiles(rootPath);
string destinationFolder = Path.Combine(rootPath, "subfolderA");

foreach (string file in files)
{
    string destFile = Path.Combine(destinationFolder, Path.GetFileName(file));
    File.Move(file, destFile);
}

string[] files = Directory.GetFiles(rootPath);
string destinationFolder = Path.Combine(rootPath, "subfolderA");

foreach (string file in files)
{
    string destFile = Path.Combine(destinationFolder, Path.GetFileName(file));
    File.Move(file, destFile);
}

Ce code déplace les fichiers du répertoire racine vers subfolderA et les supprime du répertoire source.

Créer des applications utilitaires

Tim encourage les développeurs à réfléchir aux différentes façons dont ils peuvent utiliser C# pour automatiser les tâches du système de fichiers et créer des applications utilitaires. Il suggère de commencer par des tâches simples et d'élaborer progressivement des solutions d'automatisation plus complexes.

Exemples d'applications utilitaires :

• Nettoyage des fichiers temporaires : Automatisez le processus de suppression des fichiers temporaires pour libérer de l'espace.

• Sauvegardes sur disques externes : Créez un outil de sauvegarde qui copie les fichiers importants sur un disque externe.

• Synchronisation des dossiers de projet : Synchronisez les dossiers de projet entre un ordinateur et une clé USB, en veillant à ce que les dernières modifications soient toujours sauvegardées et restaurées.

Conclusion

L'exploration par Tim Corey des opérations du système de fichiers en C# offre un aperçu pratique de l'automatisation des tâches liées aux fichiers et de la gestion des répertoires. En suivant ses exemples, les développeurs peuvent automatiser efficacement les tâches routinières de gestion de fichiers et créer des applications utilitaires personnalisées.

Pour approfondir votre compréhension et voir ces concepts en action, je vous encourage vivement à regarder la vidéo complète de Tim C# sur le Système de fichiers en C#. Ses explications détaillées et ses exemples pratiques vous aideront à consolider votre compréhension et vous permettront de créer vos propres applications de gestion de fichiers.