Choisir les options d'E/S de fichier dans Visual Basic .NET
Cat Francis
L'équipe Visual Studio
Microsoft Corporation
Résumé : cet article s'adresse aux programmeurs Visual Basic qui s'interrogent sur la multiplicité des approches d'E/S de fichier dans Visual Basic .NET. Les solutions disponibles incluent les méthodes fournies par le runtime Visual Basic .NET, l'objet FileSystemObject et les méthodes du Common Language Runtime. À la fin de l'article, le développeur expérimenté aura pu se familiariser avec les trois approches et sera en mesure de faire un choix.
Cet article contient des liens vers des pages en anglais.
Sommaire
Introduction
Méthodes de
fichiers dans Visual Basic .NET
FileSystemObject dans
Visual Basic .NET
Méthodes des
fichiers du Common Language Runtime
Conclusion
Introduction
Les développeurs chevronnés en Visual Basic® pourraient conclure d'emblée que les modifications apportées à Visual Basic .NET ont transformé un territoire familier en une contrée sauvage et sans repères. En réalité, les cartes qu'ils ont élaborées au cours de leurs explorations passées restent utilisables. Les méthodes d'E/S de fichier du runtime Visual Basic, par exemple, doivent sembler familières. De même, ceux qui se sont déjà lancés à la découverte de l'objet FileSystemObject peuvent poursuivre sans crainte leur exploration. Et si l'univers du Common Language Runtime peut apparaître non balisé et plein d'obstacles orientés objet, il est également riche de perspectives attrayantes qui offrent, par exemple, de nouvelles fonctionnalités dans les classes FileSystemWatcher ou FileIOPermissions.
En fait, le seul aspect délicat pour un développeur Visual Basic .NET est de choisir parmi ces trois approches. La manipulation des fichiers et des répertoires est essentielle pour de nombreuses applications, mais l'approche souple de Visual Basic .NET peut s'avérer déroutante et faire naître des questions telles que : Quelle sorte d'accès aux fichiers Visual Basic .NET propose-t-il ? Quand faut-il utiliser l'objet FileSystemObject ? Quels sont les avantages des méthodes du Common Language Runtime ? Faut-il se limiter à une seule approche ? Comment choisir une méthode ?
Méthodes de fichiers dans Visual Basic .NET
L'observation de l'espace de noms Microsoft.VisualBasic devrait réconforter le développeur intimidé à la pensée d'un monde .NET tout neuf. L'espace de noms est rempli de quantité de fonctions et de méthodes familières. Si certains noms ont été légèrement modifiés, la très grande majorité est restée identique : Dir, Input, Print, Seek, Write, etc.
Pour choisir parmi les fonctions runtime, la considération principale est le type d'information que vous écrivez dans un fichier ou que vous obtenez de celui-ci. Visual Basic .NET offre des méthodes pour trois types d'accès aux fichiers, en fonction du type de données : binaire, séquentiel et aléatoire.
- L'accès binaire, qui permet de stocker et d'accéder aux données d'un fichier sous la forme de votre choix, est particulièrement utile pour les champs de longueur variable.
- L'accès aléatoire, qui permet de stocker et d'accéder aux informations sous forme d'enregistrements dont la longueur est supposée être identique.
- L'accès séquentiel, qui permet de lire et d'écrire des chaînes dans des fichiers texte.
Pour plus d'informations, reportez-vous à
Data Access Functions 
.
Quelques changements sont intervenus au niveau des fonctions
utilisées dans ces différents types d'accès aux
fichiers. Le changement le plus notable est le remplacement des
fonctions Put et Get par
FilePut/FilePutObject et
FileGet/FileGetObject. Dans Visual Basic .NET,
FilePut et FileGet correspondent aux fonctions
Put et Get ; FilePutObject et
FileGetObject servent à écrire un objet de
type Object (l'équivalent du type Variant
dans les versions précédentes de Visual Basic) dans
le fichier. Pour plus d'informations, reportez-vous à
Variant .
Par exemple, voici un code dans Visual Basic 6.0 :
Dim Person As Variant
If IdentifyPeopleByName Then
Person = "My Name1"
Else
Person = 564
EndIf
Put #1, , Person
Dans Visual Basic .NET, il devient :
FileOpen(1, "c:\test.txt", OpenMode.Binary)
Dim Person As Object
If IdentifyPeopleByName Then
Person = "My Name1"
Else
Person = 564
EndIf
FilePutObject(1, Person)
FileClose(1)
Dans l'ensemble toutefois, le programmeur Visual Basic chevronné ne devrait pas rencontrer de grosses difficultés ! Le tableau qui suit donne la liste des fonctions employées pour la manipulation des fichiers et des répertoires dans Visual Basic .NET et propose des liens vers les rubriques qui en donnent la description.
|
Avantages et inconvénients
Deux avantages essentiels des fonctions offertes par le runtime Visual Basic .NET sont la familiarité et la simplicité d'utilisation. De par sa conception familière, intuitive et souple, Visual Basic .NET fournit une plate-forme d'exploration confortable de .NET.
De même, la mise à niveau d'un programme
écrit dans une version précédente de Visual
Basic vers son homologue .NET ou la création d'une
application capable d'interagir avec d'autres applications
écrites dans des versions précédentes devrait
être relativement simple. Pour plus d'informations sur la
mise à niveau de versions précédentes du code,
reportez-vous à
Preparing a Visual Basic 6.0 Application for Upgrading .
Les fonctions de Visual Basic .NET offrent également l'accès binaire aux fichiers, contrairement à l'objet FileSystemObject (décrit plus loin), de sorte que leur choix s'avère plus adapté lorsque vous travaillez avec des champs de longueur variable.
Enfin, il n'existe aucune contrainte particulière, telle que la nécessité d'importer des espaces de noms, lorsque vous utilisez les fonctions intégrées d'E/S de fichier de Visual Basic .NET depuis Visual Basic .NET.
En revanche, le fait que les fonctions d'E/S de fichier de Visual Basic .NET ne prennent pas en charge d'autres types d'écriture que String, Date, Integer, Long, Single, Double, Decimal, ni les structures et les tableaux de ces types, constitue un inconvénient. Par ailleurs, il est impossible de sérialiser les classes et les performances risquent de ne pas être aussi bonnes que si vous utilisez directement les classes System.IO.
Exemples de code
Comme le montrent les exemples suivants, la manipulation de fichiers et de répertoires avec les méthodes du runtime Visual Basic est simple.
Le code de l'exemple ci-dessous vérifie si un fichier existe et, dans l'affirmative, utilise la fonction FileCopy pour le copier dans un nouveau fichier.
Private Sub CopyFiles()
Dim checkFile As String
checkFile = Dir$("c:\test.txt")
If checkFile = "test.txt"
FileCopy "c:\test.txt", "c:\new.txt"
End If
End Sub
L'exemple ci-après utilise la fonction FilePut,
qui correspond à la fonction Put des versions
précédentes de Visual Basic, pour écrire des
données dans un fichier. Trois enregistrements de la
structure CustomerRecord sont
écrits dans le fichier.
Structure CustomerRecord
Public OrderNumber As Integer
Public Name As String
Public OrderDate As Date
End Structure
Sub WriteData()
Dim MyRecord As CustomerRecord
Dim RecordNumber As Integer
Dim RecordDate As Date
' Ouvre le fichier pour l'accès aléatoire.
FileOpen(1, "C:\TESTFILE.txt", OpenMode.Binary)
For RecordNumber = 1 To 3
' À répéter 3 fois.MyRecord.OrderNumber = RecordNumber ' Définit OrderNumber.
MyRecord.OrderDate = RecordDate ' Définit OrderDate.
MyRecord.Name = "My Name" & RecordNumber ' Crée une chaîne.
FilePut(1, MyRecord) ' Écrit l'enregistrement dans le fichier.
Next RecordNumber
FileClose(1)
End Sub
FileSystemObject
Comme les fonctions et méthodes de l'espace de noms Microsoft.VisualBasic, l'objet FileSystemObject semblera familier aux utilisateurs des versions précédentes de Visual Basic. Il reste utilisable dans Visual Basic .NET.
Le modèle FileSystemObject (FSO) présente les fichiers, les répertoires et les lecteurs en tant qu'objets COM, chacun possédant ses propres propriétés et méthodes. Vous pouvez créer et manipuler ces objets et en utiliser les propriétés pour découvrir des informations telles que le contenu d'un répertoire, la taille d'un fichier, l'heure de création d'un fichier, etc. Vous accédez aux objets représentant les fichiers, les répertoires et les lecteurs du système en créant une instance de l'objet FileSystemObject puis en y accédant.
Le modèle d'objet FSO, qui figure dans la
bibliothèque de types de l'Exécutable de Microsoft
Scripting (Scrrun.dll), gère la création et la
manipulation de fichiers texte par l'intermédiaire de
l'objet TextStream. Pour plus d'informations,
reportez-vous à
TextStream . La classe FileStream présente
un flux autour du fichier, ce qui permet les opérations de
lecture et d'écriture synchrones et asynchrones sur un
système de fichiers, ainsi que la mise en mémoire
tampon des entrées et sorties en vue d'optimiser les
performances. Les informations sont écrites dans le tampon
et le contenu de celui-ci n'est écrit dans le fichier que
lorsque le tampon est plein ou lorsqu'une méthode
Close est appelée. Pour plus d'informations,
reportez-vous à
FileStream .
Avantages et inconvénients
Le principal avantage du FSO est qu'il rassemble un certain nombre de fonctions d'E/S de fichier dans un même objet. En créant une instance de l'objet, vous pouvez accéder à ses méthodes et à ses propriétés.
Le tableau ci-dessous fournit la liste des composants de base du modèle d'objet FSO et contient des liens vers des rubriques qui répertorient les propriétés et les méthodes adaptées à la création et à la manipulation des fichiers, des lecteurs et des répertoires.
|
Le modèle d'objet FSO est également bien adapté au threading. Il offre un constructeur pour les E/S asynchrones, par exemple pour utiliser les méthodes BeginRead et BeginWrite, qui permet au thread principal de se poursuivre et à l'utilisateur de traiter les données ultérieurement. Plusieurs requêtes d'E/S peuvent être en attente simultanément.
Le FSO présente toutefois plusieurs inconvénients. Comme on l'a vu plus haut, il ne fonctionne qu'avec des fichiers texte. Pour manipuler des fichiers binaires, vous devez utiliser des pointeurs vers une adresse en mémoire, ou des tableaux d'octets, qui ne sont pas pris en charge par l'objet.
De plus, lorsque vous lisez ou écrivez un contenu volumineux, les informations stockées dans le tampon peuvent générer un taux d'accès mémoire très élevé. Enfin, vous ne pouvez pas gérer les permissions ou les attributs des fichiers et des dossiers.
Comment effectuer l'implémentation
L'Explorateur d'objets vous permet de voir les objets, les collections, les propriétés, les méthodes, les événements et les constantes du modèle FSO. Pour afficher le FSO dans l'Explorateur d'objets, vous devez d'abord ajouter une référence à la bibliothèque de types de l'Exécutable de Microsoft Scripting.
Pour ajouter une référence à la bibliothèque de types de l'Exécutable de Microsoft Scripting
- Dans le menu Projet, cliquez sur Ajouter une référence.
- Dans l'onglet COM, sélectionnez Exécutable de Microsoft Scripting, cliquez sur Sélectionner, puis sur OK.
À présent, le FSO apparaît dans l'Explorateur d'objets dans le nœud Interop.Scripting.
Pour programmer avec l'objet FileSystemObject
-
Créez un objet FileSystemObject en utilisant la
méthode CreateObject
ou
Dimensionnez une variable en tant qu'objet FileSystemObject. Par exemple :
Dim MyFileStream as Scripting.New FileSystemObject. - Utilisez la méthode appropriée sur l'objet qui vient d'être créé.
- Accédez aux propriétés de l'objet.
Exemple de code
L'exemple qui suit utilise une instance de l'objet FileSystemObject pour lire un fichier et écrire son contenu.
Public Class UsesScripting
Public Shared Sub Main()
Dim fileSystem As New Scripting.FileSystemObject()
Dim file As Scripting.TextStream
file = fileSystem.OpenTextFile("c:\test.txt", _
Scripting.IOMode.ForReading, False,_
Scripting.Tristate.TristateUseDefault)
Dim contents As String = file.ReadAll()
Console.WriteLine(contents)
file.Close()
End Sub
End Class
Classes .NET Framework
L'espace de noms System.IO contient des classes File et Directory qui offrent les fonctionnalités essentielles pour manipuler des fichiers et des répertoires. Du fait que toutes les méthodes sont des membres statiques ou partagés de ces objets, vous pouvez les utiliser directement sans créer d'abord une instance de la classe.
Le tableau suivant répertorie les méthodes de la classe File.
|
Le tableau suivant illustre les méthodes associées à la classe Directory.
|
Avantages et inconvénients
Avec le Common Language Runtime, vous bénéficiez
d'une bibliothèque de classes d'une grande richesse. Par
exemple, l'espace de noms System.IO offre des services
au-delà de l'E/S de fichier de base, tels que la classe
FileSystemWatcher qui permet de surveiller les
modifications des fichiers, et les classes FileInfo et
DirectoryInfo qui permettent de rassembler des
informations concernant un fichier ou un répertoire
spécifié. Pour plus d'informations, reportez-vous
à
FileSystemWatcher ,
FileInfo et
DirectoryInfo .
De même, le Common Language Runtime offre la classe
FileIOPermission qui permet de contrôler
l'accès aux fichiers et aux répertoires. Cela peut
être particulièrement important pour les
développeurs qui travaillent avec Web Forms, lequel
fonctionne par défaut dans le contexte d'un utilisateur
local spécial nommé ASPNET et créé lors de
l'installation d'ASP.NET/Frameworks. Lorsqu'une application de
ce type requiert l'accès à une ressource, la
requête s'effectue dans le contexte de cet utilisateur.
Cependant, par défaut, l'utilisateur ASPNET dispose
d'autorisations limitées qui risquent de lui interdire
certaines actions, telles que l'écriture dans un fichier
à partir d'une application Web. Pour plus d'informations,
reportez-vous à
FileIOPermission .
Le Common Language Runtime est également compatible avec d'autres langages .NET, tels que Visual C#?, et aide à garantir la cohérence entre les applications, ce qui peut constituer un atout considérable à l'échelle d'une entreprise.
Un manque de pratique du Common Language Runtime peut poser problème à un programmeur Visual Basic qui commence juste à se familiariser avec ces nouvelles approches. Si vous êtes dans ce cas, vous choisirez probablement pour quelques temps encore des méthodes que vous connaissez bien.
Comment effectuer l'implémentation
Comme nous l'avons expliqué plus haut, de nombreuses
classes .NET Framework, telles que FileIOPermission,
sont utiles au développeur Visual Basic qui manipule des
fichiers et des répertoires. L'instruction Imports
permet de référencer des classes dans un espace de
noms sans utiliser un nom complet. Pour plus d'informations,
reportez-vous à
System.IO.FileStream et
Imports .
Exemples de code
L'exemple qui suit utilise la classe StreamReader pour lire le contenu d'un fichier texte.
Imports System
Imports System.IO
Function ReadTextFile(ByVal path As String) As String
Dim sr As
System.IO.StreamReader
Dim Contents As String
sr = New StreamReader(path)
Contents = sr.ReadToEnd()
sr.Close()
Return Contents
End Function
Le code suivant inverse l'opération (écriture au lieu de lecture) en utilisant la même approche avec la classe StreamWriter pour écrire dans un fichier texte.
Imports System
Imports System.IO
Sub WriteTextFile(ByVal path As String, ByVal value As String)
Dim sr As StreamWriter
Dim Contents As String
sr = New StreamWriter(path)
sr.Write(value)
sr.Close()
End Sub
L'exemple ci-dessous illustre l'utilisation de la classe FileSystemWatcher pour surveiller les modifications d'un répertoire. Il déclare une instance de la classe FileSystemWatcher, indique le chemin d'accès ainsi que les éléments à surveiller, puis crée un gestionnaire d'événements pour surveiller la création de nouveaux fichiers.
Imports System
Imports System.IO
Imports System.Xml
Imports System.Xml.Serialization
Class WatchForNewFiles
Shared Sub Main()
Dim fw As New System.IO.FileSystemWatcher()
' Chemin d'accès à surveiller.
fw.Path = "C:\"
' Fichiers à surveiller.
fw.NotifyFilter = System.IO.NotifyFilters.FileName
fw.IncludeSubdirectories = True
' Ajoute le gestionnaire d'événements surveillant la création de fichiers.
AddHandler fw.Created, _
New System.IO.FileSystemEventHandler(AddressOf OnFileEvent)
fw.EnableRaisingEvents = True
Console.ReadLine()
End Sub
' Événement déclenché lorsqu'un nouveau fichier est créé.
Shared Sub OnFileEvent(ByVal source As Object, ByVal e As _
System.IO.FileSystemEventArgs)
Console.WriteLine("Nouveau fichier créé dans C: " & e.FullPath)
End Sub
End Class
L'exemple ci-dessous montre comment enregistrer une classe Visual Basic .NET en utilisant les classes du Common Language Runtime. Vous pouvez vous servir des classes BinaryFormatter et BinaryWriter/Binary Reader, ce qui est efficace mais probablement moins lisible. Vous avez également la possibilité d'utiliser les classes XMLSerializer et FileStream, plus portables et plus lisibles, mais éventuellement moins efficaces.
Imports System
Imports System.IO
Imports System.Xml
Imports System.Xml.Serialization
Public Module Module1
Public Class class1
Public classvar As Integer
End Class
Sub Main()
Try
Dim Result As Object
' Crée et initialise la classe à enregistrer (sérialisée).
Dim myclass1 As New class1()
myclass1.classvar = 7
' Crée le sérialiseur.
Dim xs As New XmlSerializer(GetType(class1))
' Crée le flux du fichier.
Dim FStream As New IO.FileStream("c:\xyz.txt", _
IO.FileMode.OpenOrCreate)
' Écrit la classe en utilisant le sérialiseur.
xs.Serialize(FStream, myclass1)
' Réinitialise la position du flux du fichier au début.
Fstream.seek(0, IO.SeekOrigin.Begin)
' Lit la classe par désérialisation d'un objet.
Result = xs.Deserialize(FStream)
FStream.Close()
' Ouvre le flux du fichier sous forme de texte, lit/imprime en XML pour la classe.
console.WriteLine(readxml())
Catch e As Exception
console.WriteLine(e.ToString)
End Try
End Sub
Function ReadXML() As String
Dim MyReader As StreamReader = File.OpenText("c:\xyz.txt")
Dim str As String
Dim al As ArrayList = New ArrayList()
Do
str = MyReader.ReadLine()
If str <> Nothing Then
ReadXML &= str & vbcrlf
End If
Loop Until str = Nothing
Return ReadXML
End Function
End Module
Conclusion
Chacune de ces approches, qu'elle utilise les méthodes du runtime Visual Basic .NET, qu'elle fasse appel à l'objet FileSystemObject ou qu'elle s'appuie sur les fonctions de .NET Framework, présente des avantages et des inconvénients selon la situation et l'application. Une application qui gère de très gros fichiers sera plus performante avec la mise en œuvre des fonctions du Common Language Runtime qu'avec l'approche FSO. Une application appelée à interagir avec d'autres applications écrites dans des versions précédentes de Visual Basic fonctionnera mieux si elle utilise les méthodes du runtime Visual Basic. Dans chaque cas, vous devez évaluer les besoins de l'application, le contexte dans lequel elle sera exécutée, sans oublier vos propres affinités avec l'une ou l'autre des approches.
Comme vous le voyez, l'horizon du programmeur Visual Basic s'est élargi depuis les versions précédentes, de façon à vous offrir de nouvelles perspectives de fonctionnalités. Le plus souvent, la meilleure solution consiste à combiner ces approches, en adoptant ponctuellement celle qui répond le mieux à un besoin particulier de l'application. À vous de choisir si vous préférez rester en terrain connu ou vous aventurer dans la recherche de méthodes nouvelles.
Dernière mise à jour le vendredi 14 juin 2002
