.Net et la manipulation de fichiers texte (C#)

Utilisation et manipulation de fichiers texte dans vos applications ASP.Net grâce aux classes fournies par le .Net Framework

N'hésitez pas à commenter cet article ! Commentez Donner une note à l'article (5)

Article lu   fois.

L'auteur

Profil ProSite personnel

Liens sociaux

Viadeo Twitter Facebook Share on Google+   

Introduction

La manipulation de fichiers texte peut être fort utile dans la réalisation d'applications .Net qu'elles soient WebForm ou WinForm, il est très fréquent d'avoir besoin de stocker des informations dans un fichier. Ce que nous allons effectuer au cours de l'article est en fait apprendre à lire et écrire des fichiers, effectuer des opérations sur ceux-ci et interagir avec leurs attributs, ce qui implique consultation et modification.

1. Les classes dans le Framework .Net

Une fois de plus le Framework possède toutes les classes nécessaires à la réalisation d'opérations de bases voir même un petit peu plus complexes. Nous allons voir rapidement quelles sont ces classes et qu'elles sont leur utilité.

Tout d'abord je précise que l'espace de noms concerné est System.IO, il faudra donc l'importer pour utiliser ses différentes classes. Pour cela il faut ajouter cette ligne de code :

 
Sélectionnez

		using System.IO;

System.IO permet la lecture et l'écriture de fichiers et de flux de données.

Les méthodes qui vont nous être utiles sont fournies par deux classes, qui sont, File et FileInfo. Toutes deux présentent des méthodes similaires à une différence près : elles sont statiques pour la classe File et d'instance pour FileInfo. Concrètement la différence va se voir au niveau de l'écriture de ces méthodes, pour FileInfo il faudra d'abord créer une instance de cette dernière avant de pouvoir employer ses méthodes, ce qui n'est pas le cas pour File, dont les méthodes sont accessibles sans instanciation de la classe elle-même.

Nous allons également utiliser deux autres classes de l'espace de noms System.IO : StreamReader et StreamWriter. Leur rôle est en relation avec leur nom, StreamReader permet, en effet, de lire un flux de caractères depuis un fichier, StreamWriter, vous l'aurez compris, permet l'écriture.

Remarque : Ici nous travaillons avec des fichiers texte, mais le framework .Net offre la possibilité de travailler avec des fichiers binaires (grâce notamment aux classes BinaryReader et BinaryWriter), ainsi qu'au format XML grâce à l'espace de noms System.XML.

2. Lecture et écriture de fichiers texte

La lecture et l'écriture sont bien évidemment les deux opérations majeures dans la manipulation de fichiers texte. Pour cela, il existe un certain nombre de classes et de méthodes qui nous aide à les réaliser. Voyons cela d'un peu plus près.

2.1. La lecture

Code permettant la lecture du contenu d'un fichier texte :

 
Sélectionnez

public void lectureFichier(string fichier) 
{ 
  try 
  { 
    // Création d'une instance de StreamReader pour permettre la lecture de notre fichier 
    StreamReader monStreamReader = new StreamReader(Server.MapPath(fichier)); 
    string ligne = monStreamReader.ReadLine(); 

    // Lecture de toutes les lignes et affichage de chacune sur la page 
    while (ligne != null) 
    { 
      Response.Write(ligne); 
      Response.Write("</br>"); 
      ligne = monStreamReader.ReadLine(); 
    } 
    // Fermeture du StreamReader (attention très important) 
    monStreamReader.Close(); 
  } 
  catch (Exception ex) 
  { 
    // Code exécuté en cas d'exception 
    Response.Write("Une erreur est survenue au cours de la lecture !"); 
    Response.Write("</br>"); 
    Response.Write(ex.Message); 
  } 
}

Appel de la fonction permettant la lecture du fichier, vous pouvez voir qu'on passe le chemin relatif du fichier en paramètre.

 
Sélectionnez

lectureFichier("./admin/logs/application.log");

Explication de ce code :

Comme toujours, l'important n'est pas d'avoir ce code pour le copier, mais de le comprendre.


L'instanciation du StreamReader :

Lors de l'instanciation (désolé, ce terme n'est pas très français, mais on le comprend bien) de cette classe, il est possible de spécifier le codage employé par notre fichier texte, par défaut, il s'agit d'UTF-8. On passe aussi lors de l'instanciation le chemin physique du fichier, ici comme nous sommes dans une application ASP.Net nous utilisons Server.MapPath() qui permet d'obtenir le chemin physique à partir du chemin relatif du fichier, cela permet d'éviter la difficile gestion des chemins relatifs et physiques.


Le Do … Loop :

Cette boucle permet d'extraire ligne après ligne le contenu de notre fichier, et cela grâce à la méthode ReadLine() appliquée à notre StreamReader. Cette méthode permet donc de lire chaque ligne et retourne les données lues sous forme de chaînes. La boucle se poursuit tant qu'il reste une ligne à lire, cela est géré par le Until ligne Is Nothing.

Il existe aussi la méthode Read() qui permet de lire un flux de données sans faire la distinction de lignes. Read() et ReadLine() sont des méthodes de la classe TextReader.


monStreamReader.Close() :

Cette méthode est extrêmement importante, il ne faut surtout pas l'oublier. En effet, en cas d'oubli de fermeture de votre StreamReader, vous ne pourrez plus accéder à votre fichier par la suite, car, en fait, le processus ASP.Net aura mis un verrou sur ce fichier. Pour retrouver un accès normal au fichier, il faudrait alors redémarrer le processus ASP.Net, vous voyez donc qu'il est très important de ne pas oublier de fermer ce StreamReader.

2.2. L'écriture

Voilà le code permettant d'écrire dans un fichier texte :

 
Sélectionnez

public void ecritureFichier (string fichier) 
{ 
  try 
  { 
    // Instanciation du StreamWriter avec passage du nom du fichier 
    StreamWriter monStreamWriter = new StreamWriter(Server.MapPath("./") + @"admin\logs\" + fichier); 
    // ou bien 
    // StreamWriter monStreamWriter = new StreamWriter(Server.MapPath("./") + "admin\\logs\\" + fichier); 

    //Ecriture du texte dans votre fichier 
    monStreamWriter.WriteLine("Ma toute première ligne ..."); 
    monStreamWriter.WriteLine("Ma seconde ligne ..."); 
    monStreamWriter.WriteLine("Ma troisième ligne ..."); 

    // Fermeture du StreamWriter (Très important) 
    monStreamWriter.Close(); 
  } 
  catch (Exception ex) 
  { 
    // Code exécuté en cas d'exception 
    Response.Write(ex.Message); 
  } 
}

Explication du code :


Instanciation du StreamWriter :

Nous créons ici une instance, StreamWriter qui permet d'écrire dans un flux, et comme StreamReader, il est possible de spécifier le codage utilisé, par défaut il s'agit ici aussi d'UTF-8. Nous passons le chemin physique du fichier dans le constructeur.


WriteLine() :

Ici, la méthode WriteLine nous permet d'écrire dans notre fichier, elle a la particularité d'écrire ligne après ligne, c'est-à-dire que à chaque fois qu'on l'appelle, elle ajoute une nouvelle ligne à notre fichier.


Write() :

Comme WriteLine, la méthode Write permet d'écrire dans un fichier sauf qu'elle écrit un flux sans se préoccuper des lignes, elle est donc utile quand le retour à la ligne n'est pas souhaité après chaque ajout dans le fichier. Nous ne l'utilisons pas ici mais je vous l'indique car elle très utile.


monStreamWriter.Close() :

Comme pour le StreamReader, il faut absolument fermer le StreamWriter après utilisation sous peine des mêmes conséquences, à savoir un accès impossible au fichier sans un redémarrage du processus ASP.Net.


Remarque : Attention, le compte ASPNET (sous Windows 2003 Server ce compte n'est pas ASPNET mais IIS_WPG) sur le serveur doit avoir une permission en écriture sur le répertoire devant contenir votre fichier. Si le compte ASPNET n'a pas les permissions adéquates, cela va soulever une exception pour accès refusé au système de fichiers.

3. Choix de l'encodage du fichier

Comme je vous l'ai expliqué précédemment, vous pouvez choisir le codage à utiliser avec votre StreamWriter lorsque vous allez écrire dans ce fichier. Pour cela, il faut ajouter l'encodage au constructeur de votre StreamWriter, rien de bien compliqué.

Voilà un exemple de constructeur :
Sélectionnez

string fichier = Server.MapPath("test.txt"); 
StreamWriter monStreamWriter = new StreamWriter(fichier, True, System.Text.Encoding.ASCII);

Expliquons un peu ce code :

La première ligne sert uniquement à récupérer le chemin physique du fichier test.txt se trouvant à la racine de notre application.

La deuxième ligne est le constructeur lui-même, en premier nous lui passons le chemin du fichier. Après le booléen est là pour la méthode append, s' il est positionné à True alors le texte sera ajouté au fichier s'il existe déjà, s'il est à False le fichier sera effacé et recré s'il existe déjà. Et pour terminer, nous passons le codage au constructeur, on le définit de la manière suivante : System.Texte.Encoding.codage. Le codage peut être ASCII, Unicode, UTF7, UTF8. Sans précision, le codage par défaut est UTF8.

4. Autres opérations sur les fichiers

En dehors de la lecture et de l'écriture de fichier, nous pouvons avoir besoin d'effectuer d'autres opérations sur les fichiers, nous allons voir les principales ici :

4.1. Opérations en lecture sur les fichiers

Récupérer la taille du fichier :

La méthode à employer pour obtenir la taille d'un fichier est Length, elle retourne une taille en octets.

Exemple :

 
Sélectionnez

FileInfo mon_fichier = new FileInfo(Server.MapPath("test.txt")); 
string taille = mon_fichier.Length.ToString(); 
Response.Write(taille);

Date de création

La date de création d'un fichier est accessible grâce à la méthode CreationTime() de la classe FileInfo.

Exemple :

 
Sélectionnez

FileInfo mon_fichier = new FileInfo(Server.MapPath("test.txt")); 
string date_fichier = mon_fichier.CreationTime.ToLongDateString(); 
Response.Write(date_fichier);

Dernière modification

La dernière modification d'un fichier est une information qui est stockée dans le fichier, la méthode LastWriteTime() permet d'y accéder.

Exemple :

 
Sélectionnez

FileInfo mon_fichier = new FileInfo(Server.MapPath("test.txt")); 
string last_modif = mon_fichier.LastWriteTime.ToString(); 
Response.Write(last_modif);

Dernier accès au fichier

Dans certaines applications, il peut être utile de savoir quand un fichier a été accédé pour la dernière fois, comme cette information est stockée dans le fichier même, il n'y a qu'à la récupérer avec la méthode LastAccessTime().

Exemple :

 
Sélectionnez

FileInfo mon_fichier = new FileInfo(Server.MapPath("test.txt")); 
string last_acces = mon_fichier.LastAccessTime.ToString(); 
Response.Write(last_acces);

Extension du fichier

Nous allons ici récupérer l'extension du fichier que l'on souhaite, pour cela il faut juste utiliser la méthode Extension.

Exemple :

 
Sélectionnez

FileInfo mon_fichier = new FileInfo(Server.MapPath("test.txt")); 
string extension = mon_fichier.Extension.ToString(); 
Response.Write(extension);

Nous avons vu comment récupérer certains attributs et comment réaliser certaines manipulations, mais il y en a d'autres, le but de cet article n'étant pas de les cataloguer, je vous renvoie à la documentation des classes concernées. La démarche restant la même pour l'ensemble des autres attributs et opérations, cela ne vous posera pas de problème particulier.

Nous avons vu ici dans un premier temps comment accéder aux diverses informations "en lecture", c'est-à-dire sans aucune modification du fichier, nous allons maintenant voir ce qu'il est possible "en écriture".

4.2. Opérations en écriture

Effacer un fichier

Permet d'effacer un fichier, vous pouvez voir que c'est une opération plus qu'aisée, en effet, une méthode a été prévue pour cela, il s'agit simplement de la méthode Delete().

Exemple :

 
Sélectionnez

FileInfo mon_fichier = new FileInfo(Server.MapPath("test.txt")); 
mon_fichier.Delete();

Créer un fichier

Création d'un fichier vide, il faut bien entendu que le compte ASPNET ait les droits d'écriture sur le répertoire concerné.

Exemple :

 
Sélectionnez

FileInfo mon_fichier = new FileInfo(Server.MapPath("test.txt")); 
mon_fichier.Create();

Modifier la date de création

Pour cela, vous devez utiliser la méthode SetCreationDate, il faut y passer le chemin physique complet du fichier, et ensuite la nouvelle date au format DateTime. Attention la date est donc au format mm/jj/aaaa, pour l'heure il s'agit de l'heure GMT; le système va lui ajouter automatiquement 1 heure de plus (si votre système se trouve dans la zone GMT+1 bien évidemment), en clair si vous entrez 01:00:00 sur votre fichier apparaîtra 02:00:00.

Exemple :

 
Sélectionnez

string chemin = Server.MapPath("test.txt"); 
File.SetCreationTime(chemin, new DateTime(2000,12,5,2,25,55));

Positionner un fichier en fichier caché

Nous utilisons ici la méthode SetAttributes en y passant le chemin du fichier ainsi que l'attribut à modifier.

Exemple :

 
Sélectionnez

string chemin = Server.MapPath("test.txt"); 
File.SetAttributes(chemin, FileAttributes.Hidden);

Positionner un fichier en lecture seule

Il est possible de positionner un fichier en "lecture seule", pour cela rien de compliqué.

Exemple :

 
Sélectionnez

string chemin = Server.MapPath("test.txt"); 
File.SetAttributes(chemin, FileAttributes.ReadOnly);

Conclusion

Le bilan que l'on peut tirer de cet article est que l'on peut réaliser quasiment tout ce qui est imaginable, ou enfin presque… Le Framework .Net offre les classes nécessaires à la manipulation de fichiers texte.

Cependant, nous sommes dans une application ASP.Net donc il ne faut pas oublier que les fichiers manipulés le sont côté serveur et non côté client. De plus, il faut définir les droits nécessaires (notamment en écriture) sur ces fichiers et les répertoires parents, sans cela, une exception sera levée pour " accès refusé ". Je le rappelle si c'est encore nécessaire, le compte utilisé par une application ASP.Net est tout simplement ASPNET (sauf sous Windows Server 2003, c'est alors le compte IIS_WPG).

Bon codage et profitez bien de ce que nous offre le .Net Framework dans le domaine de la manipulation de fichiers texte !

Ressources

Documentation relative aux classes employées :

Remerciements

Un trés grand merci a Freegreg pour la relecture et la réalisation de la version C#.

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

© 2004 Ronald VASSEUR - Tous droits réservés : Ronald VASSEUR. Toute reproduction, utilisation ou diffusion de ce document par quelque moyen que ce soit autre que pour un usage personnel doit faire l'objet d'une autorisation écrite préalable de la part de : Ronald VASSEUR, le propriétaire des droits intellectuels.