Apprendre le C#

Fichier système Mastering C#

Tim Corey

35m 07s

C# fournit des capacités robustes pour interagir avec le système de fichiers, permettant des tâches telles que la manipulation de fichiers, la gestion de répertoires et la recherche d'informations. Dans sa vidéo, "Travailler avec le système de fichiers en C# - Gérer les dossiers et les fichiers", Tim Corey explore les principes fondamentaux du travail avec les fichiers et les répertoires à l'aide de C#.

Cet article vise à fournir un aperçu complet des opérations du système de fichiers en C#, en mettant en évidence les techniques essentielles pour l'automatisation des tâches, la gestion des répertoires et la manipulation des fichiers.

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 une variété d'opérations sur les fichiers, comme créer des fichiers, lire des données, écrire dans les 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. Les 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 (tel que lecture, écriture ou ajout). Vous pouvez également utiliser la classe FileInfo pour obtenir plus de détails sur un fichier, tels que son heure de création ou son chemin complet. La classe DirectoryInfo vous permet de travailler avec des répertoires, d'obtenir des fichiers ou de 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();
        }
    }
}

Imports System
Imports System.IO

Namespace FileSystemDemo
    Module Program
        Sub Main(args As String())
            Console.ReadLine()
        End Sub
    End Module
End Namespace

Imports System
Imports System.IO

Namespace FileSystemDemo
    Module Program
        Sub Main(args As String())
            Console.ReadLine()
        End Sub
    End Module
End Namespace

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";

Dim rootPath As String = "C:\temp\demos\filesystem"

Dim rootPath As String = "C:\temp\demos\filesystem"

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

Lecture de tous les répertoires dans le chemin

Tim montre comment récupérer tous les répertoires dans le chemin racine spécifié à l'aide de 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);
}

Dim directories As String() = Directory.GetDirectories(rootPath)
For Each directory As String In directories
    Console.WriteLine(directory)
Next

Dim directories As String() = Directory.GetDirectories(rootPath)
For Each directory As String In directories
    Console.WriteLine(directory)
Next

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

Liste des répertoires

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);
}

Dim allDirectories As String() = Directory.GetDirectories(rootPath, "*", SearchOption.AllDirectories)
For Each directory As String In allDirectories
    Console.WriteLine(directory)
Next

Dim allDirectories As String() = Directory.GetDirectories(rootPath, "*", SearchOption.AllDirectories)
For Each directory As String In allDirectories
    Console.WriteLine(directory)
Next

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épertoire 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);
}

Dim files As String() = Directory.GetFiles(rootPath, "*.*", SearchOption.AllDirectories)
For Each file As String In files
    Console.WriteLine(file)
Next

Dim files As String() = Directory.GetFiles(rootPath, "*.*", SearchOption.AllDirectories)
For Each file As String In files
    Console.WriteLine(file)
Next

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

Liste des fichiers

Extraction de noms de fichiers et de chemins

Tim explique comment extraire les noms de fichiers et les chemins 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
}

For Each file As String 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
Next

For Each file As String 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
Next

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");
}

For Each file As String In files
    Dim info As New FileInfo(file)
    Console.WriteLine($"{Path.GetFileName(file)}: {info.Length} bytes")
Next

For Each file As String In files
    Dim info As New FileInfo(file)
    Console.WriteLine($"{Path.GetFileName(file)}: {info.Length} bytes")
Next

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 de plus 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é accédé.
CreationTime : L'heure de création du fichier.
Attributes : Les attributs du 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");
}

Dim newPath As String = "C:\temp\demos\filesystem\subfolderC"
If Directory.Exists(newPath) Then
    Console.WriteLine("Directory exists")
Else
    Console.WriteLine("Directory does not exist")
End If

Dim newPath As String = "C:\temp\demos\filesystem\subfolderC"
If Directory.Exists(newPath) Then
    Console.WriteLine("Directory exists")
Else
    Console.WriteLine("Directory does not exist")
End If

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");

Dim newPath As String = "C:\temp\demos\filesystem\subfolderC\sub-subfolderD"
Directory.CreateDirectory(newPath)
Console.WriteLine("Directories created")

Dim newPath As String = "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);
}

Dim files As String() = Directory.GetFiles(rootPath)
Dim destinationFolder As String = Path.Combine(rootPath, "subfolderA")

For Each file As String In files
    Dim destFile As String = Path.Combine(destinationFolder, Path.GetFileName(file))
    File.Copy(file, destFile, True)
Next

Dim files As String() = Directory.GetFiles(rootPath)
Dim destinationFolder As String = Path.Combine(rootPath, "subfolderA")

For Each file As String In files
    Dim destFile As String = Path.Combine(destinationFolder, Path.GetFileName(file))
    File.Copy(file, destFile, True)
Next

Dans cet exemple, les fichiers sont copiés du répertoire racine vers 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);
}

For i As Integer = 0 To files.Length - 1
    Dim destFile As String = Path.Combine(destinationFolder, $"{i}.txt")
    File.Copy(files(i), destFile, True)
Next

For i As Integer = 0 To files.Length - 1
    Dim destFile As String = Path.Combine(destinationFolder, $"{i}.txt")
    File.Copy(files(i), destFile, True)
Next

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

Gestion des écrasements de fichiers

Tim explique comment gérer les fichiers existants sans les écraser et éviter les exceptions en définissant le paramètre d'écrasement sur 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}");
}

Try
    File.Copy(sourceFile, destFile, False)
Catch ex As IOException
    Console.WriteLine($"File already exists: {ex.Message}")
End Try

Try
    File.Copy(sourceFile, destFile, False)
Catch ex As IOException
    Console.WriteLine($"File already exists: {ex.Message}")
End Try

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 lancera 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);
}

Dim files As String() = Directory.GetFiles(rootPath)
Dim destinationFolder As String = Path.Combine(rootPath, "subfolderA")

For Each file As String In files
    Dim destFile As String = Path.Combine(destinationFolder, Path.GetFileName(file))
    File.Move(file, destFile)
Next

Dim files As String() = Directory.GetFiles(rootPath)
Dim destinationFolder As String = Path.Combine(rootPath, "subfolderA")

For Each file As String In files
    Dim destFile As String = Path.Combine(destinationFolder, Path.GetFileName(file))
    File.Move(file, destFile)
Next

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.