Lire et écrire un fichier en C#

Tim Corey

24m 34s

Les opérations d'entrée et de sortie de fichiers (E/S) en C# sont une partie essentielle de nombreuses applications logicielles, permettant aux développeurs de lire et d'écrire dans des fichiers de manière efficace. Qu'il s'agisse de stocker des données, d'enregistrer des événements d'application ou de traiter de grandes quantités de données textuelles ou binaires, C# fournit des outils robustes pour travailler avec des fichiers. Dans la vidéo de Tim Corey, "C# Data Access : Fichiers texte, Tim Corey propose une présentation détaillée de ces opérations sur les fichiers, en mettant l'accent sur l'utilisation des fichiers texte pour le stockage et l'extraction de données. Cet article vise à résumer les concepts et techniques clés que Tim aborde dans la vidéo, en vous donnant un aperçu pratique des opérations d'E/S de fichiers en C#.

Introduction

En C#, les opérations d'entrée et de sortie de fichiers sont essentielles pour lire et écrire dans des fichiers texte. La classe File fournit des méthodes statiques pour interagir avec des fichiers existants ou en créer de nouveaux. StreamReader et StreamWriter sont couramment utilisés pour lire et écrire des fichiers. StreamReader lit les fichiers ligne par ligne, vous permettant d'accéder à chaque ligne de texte ou à un tableau de chaînes. Vous pouvez également utiliser la boucle while pour lire efficacement des fichiers plus volumineux. La classe StreamWriter est utilisée pour écrire des données dans un fichier, prenant en charge l'écriture de chaînes et de tableaux. Elle peut être utilisée pour ajouter du texte à un fichier existant ou réécrire le fichier entier. Des méthodes comme WriteLine et WriteText permettent une manipulation facile des données au sein des fichiers texte.

Ces opérations sont généralement effectuées dans la méthode static void Main, où vous définissez le chemin du fichier. Par exemple, vous pouvez spécifier un nom de fichier et utiliser StreamWriter pour écrire une seule chaîne ou un tableau de chaînes complet. L'instruction using garantit que le fichier est correctement fermé après les opérations, empêchant les fuites de ressources. StreamReader peut également être utilisé pour lire les fichiers ligne par ligne, et les exceptions peuvent être gérées pour gérer les erreurs potentielles lorsque le fichier n'existe pas ou ne peut pas être accédé. Ces capacités d'E/S de fichiers font de C# un excellent choix pour travailler efficacement avec des fichiers.

Tim introduit le sujet en soulignant la simplicité de la lecture et de l'écriture dans des fichiers texte en C#. Il démontre comment quelques lignes de code peuvent accomplir ces tâches, faisant des fichiers texte une option viable pour le stockage des données.

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

Tim commence par créer une nouvelle application console nommée "TextFileDataAccessDemo" à l'aide de Visual Studio.

using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;

namespace TextFileDataAccessDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.ReadLine(); // Keeps the console window open to view the output
        }
    }
}

using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;

namespace TextFileDataAccessDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.ReadLine(); // Keeps the console window open to view the output
        }
    }
}

Imports System
Imports System.IO
Imports System.Collections.Generic
Imports System.Linq

Namespace TextFileDataAccessDemo
    Class Program
        Shared Sub Main(ByVal args As String())
            Console.ReadLine() ' Keeps the console window open to view the output
        End Sub
    End Class
End Namespace

Imports System
Imports System.IO
Imports System.Collections.Generic
Imports System.Linq

Namespace TextFileDataAccessDemo
    Class Program
        Shared Sub Main(ByVal args As String())
            Console.ReadLine() ' Keeps the console window open to view the output
        End Sub
    End Class
End Namespace

Il explique l'utilisation de Console.ReadLine pour garder la fenêtre de la console ouverte, permettant aux utilisateurs de voir le résultat.

Lecture d'un fichier texte

Tim démontre comment lire à partir d'un fichier texte en utilisant la méthode File.ReadAllLines. Il montre comment gérer les chemins d'accès aux fichiers et utiliser les chaînes de caractères littéraux pour éviter les caractères d'échappement.

string filePath = @"C:\demos\test.txt";
List<string> lines = File.ReadAllLines(filePath).ToList();

string filePath = @"C:\demos\test.txt";
List<string> lines = File.ReadAllLines(filePath).ToList();

Dim filePath As String = "C:\demos\test.txt"
Dim lines As List(Of String) = File.ReadAllLines(filePath).ToList()

Dim filePath As String = "C:\demos\test.txt"
Dim lines As List(Of String) = File.ReadAllLines(filePath).ToList()

La méthode File.ReadAllLines lit toutes les lignes du fichier spécifié et les renvoie sous forme de tableau de chaînes. Tim convertit ce tableau en liste pour en faciliter la manipulation.

Écrire dans un fichier texte

Tim explique comment écrire des données dans un fichier texte en utilisant la méthode File.WriteAllLines. Il montre comment ajouter de nouvelles lignes à la liste et écrire la liste mise à jour dans le fichier.

lines.Add("Sue,Storm,WWIStorm.com");
File.WriteAllLines(filePath, lines);

lines.Add("Sue,Storm,WWIStorm.com");
File.WriteAllLines(filePath, lines);

lines.Add("Sue,Storm,WWIStorm.com")
File.WriteAllLines(filePath, lines)

lines.Add("Sue,Storm,WWIStorm.com")
File.WriteAllLines(filePath, lines)

Ce code ajoute une nouvelle entrée à la liste et écrit la liste complète dans le fichier.

Créer un modèle de données et l'alimenter à partir d'un fichier

Tim crée une classe Person pour représenter la structure de données pour chaque entrée dans le fichier texte.

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string URL { get; set; }
}

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string URL { get; set; }
}

Public Class Person
    Public Property FirstName As String
    Public Property LastName As String
    Public Property URL As String
End Class

Public Class Person
    Public Property FirstName As String
    Public Property LastName As String
    Public Property URL As String
End Class

Il lit ensuite le fichier et peuple une liste d'objets Person.

List<Person> people = new List<Person>();
List<string> lines = File.ReadAllLines(filePath).ToList();

foreach (string line in lines)
{
    string[] entries = line.Split(',');
    Person newPerson = new Person
    {
        FirstName = entries[0],
        LastName = entries[1],
        URL = entries[2]
    };
    people.Add(newPerson);
}

List<Person> people = new List<Person>();
List<string> lines = File.ReadAllLines(filePath).ToList();

foreach (string line in lines)
{
    string[] entries = line.Split(',');
    Person newPerson = new Person
    {
        FirstName = entries[0],
        LastName = entries[1],
        URL = entries[2]
    };
    people.Add(newPerson);
}

Dim people As New List(Of Person)()
Dim lines As List(Of String) = File.ReadAllLines(filePath).ToList()

For Each line As String In lines
    Dim entries As String() = line.Split(","c)
    Dim newPerson As New Person With {
        .FirstName = entries(0),
        .LastName = entries(1),
        .URL = entries(2)
    }
    people.Add(newPerson)
Next

Dim people As New List(Of Person)()
Dim lines As List(Of String) = File.ReadAllLines(filePath).ToList()

For Each line As String In lines
    Dim entries As String() = line.Split(","c)
    Dim newPerson As New Person With {
        .FirstName = entries(0),
        .LastName = entries(1),
        .URL = entries(2)
    }
    people.Add(newPerson)
Next

Ce code lit chaque ligne, la divise par des virgules, et crée un objet Person avec les données extraites.

Interpolation de chaînes de caractères

Tim présente l'interpolation de chaînes, une fonctionnalité de C# 6.0 qui simplifie le processus de combinaison de variables et de chaînes. Cette méthode utilise le symbole $ avant la chaîne et des accolades {} pour intégrer des variables directement dans la chaîne.

foreach (var person in people)
{
    Console.WriteLine($"{person.FirstName} {person.LastName}: {person.URL}");
}

foreach (var person in people)
{
    Console.WriteLine($"{person.FirstName} {person.LastName}: {person.URL}");
}

For Each person In people
    Console.WriteLine($"{person.FirstName} {person.LastName}: {person.URL}")
Next

For Each person In people
    Console.WriteLine($"{person.FirstName} {person.LastName}: {person.URL}")
Next

Cette syntaxe est plus concise et efficace comparée à la concaténation traditionnelle utilisant l'opérateur +.

Validation des données

Tim souligne l'importance de la validation des données lors de la lecture d'un fichier texte. Il souligne les risques de supposer la structure des données et recommande de vérifier la longueur des entrées fractionnées.

foreach (string line in lines)
{
    string[] entries = line.Split(',');
    if (entries.Length == 3)
    {
        Person newPerson = new Person
        {
            FirstName = entries[0],
            LastName = entries[1],
            URL = entries[2]
        };
        people.Add(newPerson);
    }
    else
    {
        // Handle error
        Console.WriteLine("Invalid data format.");
    }
}

foreach (string line in lines)
{
    string[] entries = line.Split(',');
    if (entries.Length == 3)
    {
        Person newPerson = new Person
        {
            FirstName = entries[0],
            LastName = entries[1],
            URL = entries[2]
        };
        people.Add(newPerson);
    }
    else
    {
        // Handle error
        Console.WriteLine("Invalid data format.");
    }
}

For Each line As String In lines
    Dim entries As String() = line.Split(","c)
    If entries.Length = 3 Then
        Dim newPerson As New Person With {
            .FirstName = entries(0),
            .LastName = entries(1),
            .URL = entries(2)
        }
        people.Add(newPerson)
    Else
        ' Handle error
        Console.WriteLine("Invalid data format.")
    End If
Next

For Each line As String In lines
    Dim entries As String() = line.Split(","c)
    If entries.Length = 3 Then
        Dim newPerson As New Person With {
            .FirstName = entries(0),
            .LastName = entries(1),
            .URL = entries(2)
        }
        people.Add(newPerson)
    Else
        ' Handle error
        Console.WriteLine("Invalid data format.")
    End If
Next

Cela permet de s'assurer que seules les lignes comportant le nombre correct d'entrées sont traitées, évitant ainsi les erreurs d'exécution potentielles.

Ajouter des objets à une liste

Tim démontre comment ajouter de nouveaux objets à la liste. Il utilise une instance anonyme de la classe Person pour ajouter une nouvelle personne à la liste.

people.Add(new Person { FirstName = "Greg", LastName = "Jones", URL = "WOWT.com" });

people.Add(new Person { FirstName = "Greg", LastName = "Jones", URL = "WOWT.com" });

people.Add(New Person With {.FirstName = "Greg", .LastName = "Jones", .URL = "WOWT.com"})

people.Add(New Person With {.FirstName = "Greg", .LastName = "Jones", .URL = "WOWT.com"})

Cela crée et initialise un nouvel objet Person en une seule ligne, qui est ensuite ajouté à la liste people.

Réécriture de données dans un fichier texte

Tim explique comment écrire la liste d'objets Person de nouveau dans le fichier texte. Il convertit la liste d'objets Person en une liste de chaînes, où chaque chaîne représente une ligne dans le fichier.

List<string> output = new List<string>();
foreach (var person in people)
{
    output.Add($"{person.FirstName},{person.LastName},{person.URL}");
}
File.WriteAllLines(filePath, output);

List<string> output = new List<string>();
foreach (var person in people)
{
    output.Add($"{person.FirstName},{person.LastName},{person.URL}");
}
File.WriteAllLines(filePath, output);

Dim output As New List(Of String)()
For Each person In people
    output.Add($"{person.FirstName},{person.LastName},{person.URL}")
Next
File.WriteAllLines(filePath, output)

Dim output As New List(Of String)()
For Each person In people
    output.Add($"{person.FirstName},{person.LastName},{person.URL}")
Next
File.WriteAllLines(filePath, output)

Ce code itère sur la liste people, crée une chaîne CSV pour chaque objet Person, et écrit la liste des chaînes dans le fichier.

Conclusion

Le guide détaillé de Tim Corey sur les opérations d'E/S de fichiers en C# offre un aperçu pratique de la lecture et de l'écriture dans les fichiers texte. En suivant ses exemples, les développeurs peuvent gérer efficacement les données à l'aide de fichiers texte et mettre en œuvre des solutions de stockage de données robustes. Pour une compréhension approfondie et une expérience d'apprentissage pratique, je vous encourage vivement à regarder la vidéo de Tim Corey, où il approfondit ces concepts à l'aide d'exemples concrets.