Exporter (0) Imprimer
Développer tout

Configuration des applications VB6 et VB.NET facilitée

Visual Studio .NET 2003

Station de configuration

Consultez l'article en anglais 

Téléchargez les fichiers de projet

Résumé : Il n'est pas rare que des applications aient besoin de charger et de stocker des informations de configuration. Elles peuvent en effet afficher des options spécifiques pour les utilisateurs, assurer le suivi des fichiers récemment ouverts, se rappeler les dimensions de formulaires précédents, etc. En écrivant un code VB.NET simple, vous pouvez facilement ajouter ce type de capacité de configuration à vos applications VB6 ou VB.NET existantes.

Sur cette page

Introduction Introduction
Présentation des exemples Présentation des exemples
Architecture Architecture
Musée de la configuration d'application Musée de la configuration d'application
Magie du sérialiseur XML Magie du sérialiseur XML
Traitement Traitement
Qu'en est-il de App.Config ? Qu'en est-il de App.Config ?
Conclusion Conclusion
Ressources supplémentaires Ressources supplémentaires
Scott Swigart - Biographie Scott Swigart - Biographie

Introduction

Les applications ont parfois la mémoire courte. Il vous semblerait normal que, puisque vous avez utilisé votre application pour accéder à un dossier et ouvrir un fichier, elle démarre dans ce même dossier la prochaine fois que vous voulez ouvrir un fichier. De même, il vous semblerait normal que, puisque vous avez redimensionné un formulaire, la taille et l'emplacement précédemment utilisés pour ce formulaire soient automatiquement réappliqués lors de sa prochaine ouverture. Et que dire de la commande Outils/Options ? L'utilisateur devrait pouvoir disposer d'un moyen simple pour configurer l'application afin qu'elle mémorise ces paramètres de configuration.

Il s'avère que .NET Framework dispose de grandes facilités concernant le stockage et la récupération des informations structurées à partir d'un disque, permettant ainsi à l'utilisateur d'ajouter facilement des fonctionnalités de configuration à VB.NET, ou même à des applications VB6 existantes.

Dans cet article, vous apprendrez comment ajouter des capacités de gestion de configuration à une application. Des exemples d'applications VB6 et VB.NET sont inclus ici, qui utilisent la fonctionnalité de gestion de configuration.

Présentation des exemples

Les exemples d'applications contiennent un formulaire de connexion qui peut vous servir, au besoin, à vous rappeler un nom d'utilisateur et un mot de passe :

Figure 1 : formulaire de connexion renseigné avec des informations de configuration

Figure 1

Une fois l'utilisateur connecté, un autre formulaire s'affiche. Ce formulaire présente la dernière image chargée et s'affiche à l'écran conformément à son emplacement et à sa taille précédents.

Figure 2 : formulaire préchargé avec une taille basée sur la configuration enregistrée

Figure 2

Pour commencer à utiliser les exemples, téléchargez le code associé à cet article. Lorsque vous extrayez le téléchargement, les trois dossiers suivants s'affichent : ConfigLib, ConfigExample et VB6.

Le dossier ConfigLib contient les classes utilisées pour accéder aux informations de configuration, charger ces informations et les enregistrer. Vous devez ouvrir ce projet et le compiler, ou exécuter le fichier install.bat inclus pour enregistrer ce composant en tant qu'objet COM.

ConfigExample est un projet VB.NET qui charge et enregistre les informations de configuration à l'aide de ConfigLib. VB6 est une application Visual Basic 6 qui, elle aussi, charge et enregistre les informations de configuration à l'aide de ConfigLib. Vous pouvez exécuter l'une ou l'autre de ces applications, saisir des données et fermer l'application ; lorsque vous exécuterez de nouveau l'application, vous pourrez constater qu'elle se rappellera toutes les informations que vous aurez saisies précédemment.

Architecture

Il importait que l'accès d'une application aux paramètres de configuration soit simple d'un point de vue de la programmation. Pour ce faire, l'application utilise des propriétés de classes simples pour stocker les paramètres. Ainsi, par exemple, si l'application souhaite récupérer le paramètre de hauteur d'un formulaire, le code est simplement Settings.ImageForm.Height. Plus loin dans cet article, la construction de cette classe Settings sera examinée de manière plus détaillée, mais pour l'heure, il convient simplement de comprendre que les paramètres sont stockés dans des propriétés de classes simples.

Je souhaitais également que le chargement et l'enregistrement de paramètres soient des opérations simples. Une classe SettingsManager a donc été créée pour traiter cet aspect de la gestion de la configuration.

Figure 3 : architecture de l'application

Figure 3

Toutes les informations de paramètres sont enregistrées sur le disque par la classe SettingsManager au format XML. - Mais pourquoi XML, me demanderez-vous ? Pour comprendre les avantages des fichiers de configuration XML, il convient d'explorer les différents mécanismes utilisés par les applications Windows pour les informations de configuration.

Musée de la configuration d'application

A l'origine étaient les fichiers .INI. Ces fichiers stockaient des paramètres de configuration sous forme de texte, regroupés dans différentes sections.

Liste 1 : exemple de fichier .INI

[MainForm]
height=600
width=800
		

Puis est apparu le registre, qui a soudain relégué les fichiers .INI au rang de vestiges du passé. En effet, les paramètres devaient désormais être stockés dans Le Registre (mot inquiétant). Le registre deviendrait ainsi le référentiel pour chaque paramètre de configuration imaginable. Pourtant, le registre pose problème. Si vous placez les paramètres de configuration dans le registre, vous ne pouvez pas examiner ces paramètres hors de l'application si vous ne disposez pas de connaissances internes à l'application et si vous ne savez pas où, dans le registre, elle a décidé d'écrire ses paramètres. De même, il n'existe qu'un seul registre. Ainsi, si vous prenez en charge différentes versions d'une même application installées côte à côté, vous devez vous assurer que chaque version de cette application écrit dans des emplacements de registre qui lui sont spécifiques. Si vous ne le faites pas, vos versions v1.0 et v2.0 de l'application s'immiscent dans le registre et modifient les paramètres l'une de l'autre.

Lorsque l'application enregistre les paramètres dans le registre, sa désinstallation est également plus complexe. Le programme de désinstallation doit non seulement supprimer les fichiers de l'application, mais également trouver et supprimer les paramètres du registre. Or, si votre registre ressemble au mien, il est envahi de paramètres de configuration perdus et oubliés suite à d'anciennes désinstallations d'applications. Même ainsi, Visual Basic 6 et Visual Basic .NET facilitent la lecture et l'écriture de paramètres à des emplacements spécifiques du registre avec les fonctions GetSetting et SaveSetting.

Ce qui nous amène à la situation d'aujourd'hui, où les fichiers de configuration XML sont très en vogue. Ils vous permettent de hiérarchiser en profondeur les paramètres de configuration, stockés dans un simple fichier. Ceci présente de nombreux avantages. Premièrement, la désinstallation de l'application s'en trouve facilitée, puisqu'il suffit au programme de désinstallation de supprimer ce fichier. Deuxièmement, le fichier peut être lu ou modifié manuellement à l'aide de tout éditeur de texte ou XML. Troisièmement, il est facile de stocker dans un seul fichier les paramètres de l'ensemble de l'application (chaînes de connexion de base de données, par exemple) et les paramètres utilisateur individuels dans différents fichiers. Enfin, il est facile pour différentes versions d'une même application de conserver séparément leurs paramètres, ces paramètres pouvant être enregistrés dans des dossiers spécifiques aux applications.

Liste 2 : exemple de fichier de configuration XML

‹?xml version="1.0"?›
‹Settings xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"›
  ‹LogonForm›
    ‹UserName›Scott Swigart‹/UserName›
    ‹Password›password‹/Password›
    ‹Remember›true‹/Remember›
  ‹/LogonForm›
  ‹ImageForm›
    ‹Width›6996‹/Width›
    ‹Height›6156‹/Height›
    ‹Top›3432‹/Top›
    ‹Left›5964‹/Left›
    ‹PicturePath›
C:\Documents and Settings\All Users\Documents\My Pictures\Sample Pictures\Winter.jpg‹/PicturePath›
  ‹/ImageForm›
‹/Settings›
		

L'inconvénient de la configuration XML a toujours été la lourdeur de la création et de l'analyse des fichiers XML, du moins si l'on la compare avec des fonctions simples d'utilisation comme SaveSetting et GetSetting. Toutefois, .NET Framework rend désormais sans intérêt l'enregistrement des contenus d'une classe au format XML et le rechargement de la classe à partir de XML.

Magie du sérialiseur XML

.NET Framework contient une classe appelée XmlSerializer, qui convertit les classes en XML (sérialisation) ou recrée des classes à partir de XML (désérialisation). La première fois que j'ai vu cette classe, j'ai été impressionné. C'est vraiment magique. Utilisons-la pour découvrir quelques astuces.

Astuce n° 1, la sérialisation XML

Imaginez une classe contenant des informations de configuration pour un formulaire, comme par exemple l'emplacement et la taille de ce formulaire :

Liste 3 : classe contenant des informations de configuration

Public Class FormInfo
	Public Top as Integer
	Public Left as Integer
	Public Width as Integer
	Public Height as Integer
End Class
		

Vous pouvez choisir d'enregistrer ces informations sous la forme d'un fichier de configuration. Avec VB6, vous avez besoin de code qui écrive chaque champ de manière explicite et vous devez connaître à l'avance le nom des champs. Avec VB.NET, toutefois, il vous suffit d'utiliser notre XmlSerializer magique. La formule « abracadabra » est facultative.

Liste 4 : sérialisation d'une classe au format XML

Public Sub Save(ByVal settings As FormInfo, ByVal fileName As String)
    Dim xs As New XmlSerializer(GetType(settings))
    Dim configFile As Stream = File.Open(fileName, _
        FileMode.Create, FileAccess.Write)
    xs.Serialize(configFile, settings)
    configFile.Close()
End Sub
		

Cette fonction prend une classe FormInfo, comme celle illustrée dans la liste 3, la convertit en XML et enregistre le code XML dans un fichier spécifique. Examinons ce code ligne par ligne :

Dim xs As New XmlSerializer(GetType(settings))

Cette première ligne crée une instance de XmlSerializer. Un XmlSerializer peut examiner une classe, extraire le nom et les valeurs des propriétés de la classe et émettre les informations au format XML. Une fois XmlSerializer créé, le type d'objet qu'il sera chargé de sérialiser lui est communiqué.

Dim configFile As Stream = File.Open(fileName, FileMode.Create, _
FileAccess.Write)
		

La ligne suivante ouvre un fichier à des fins d'écriture. Le contenu de la classe sérialisée sera écrit dans ce fichier disque.

xs.Serialize(configFile, settings) 
		

Le XmlSerializer est alors utilisé pour convertir le contenu d'une classe en XML et écrire les résultats dans le fichier ouvert par la ligne précédente.

configFile.Close()

Pour finir, le fichier disque est fermé. Un coup de baguette magique et vous obtenez du code XML :

Liste 5 : classe FormInfo sérialisée sous forme de code XML

‹FormInfo›
  ‹Width›800‹/Width›
  ‹Height›600‹/Height›
  ‹Top›34‹/Top›
  ‹Left›59‹/Left›
‹/FormInfo›
		

Astuce n°2, la désérialisation du XML

Faire disparaître le lapin dans une chaîne de chevrons n'est pas inintéressant, mais ce n'est que le début du tour de magie. Pour l'astuce n° 2, nous allons le faire réapparaître.

Pour recréer la classe FormInfo à partir du code XML enregistré, vous allez de nouveau utiliser la classe XmlSerializer, mais, cette fois, en utilisant la méthode de désérialisation :

Liste 6 : création d'une classe à partir d'un code XML

Public Function Load(ByVal fileName As String) As FormInfo
    Dim xs As New XmlSerializer(GetType(FormInfo))
    Dim configFile As Stream = File.Open(fileName, FileMode.Open, _
        FileAccess.Read)
    Dim settings As FormInfo = xs.Deserialize(configFile)
    configFile.Close()
    Return settings
End Function
		

Encore une fois, examinons chaque ligne l'une après l'autre.

Dim xs As New XmlSerializer(GetType(Settings)) 

Cette première ligne crée une instance du XmlSerializer et l'informe du type de classe qu'il créera à partir du fichier XML.

Dim configFile As Stream = File.Open(fileName, FileMode.Open, _
    FileAccess.Read) 
		

La deuxième ligne ouvre le fichier disque qui contient le code XML.

Dim settings As FormInfo = xs.Deserialize(configFile) 

La troisième ligne est la plus intéressante. C'est ici que le XmlSerializer lit le fichier XML, crée la classe de destination, la renseigne avec des données provenant du fichier et renvoie l'instance de la classe. Vous obtenez ainsi une nouvelle classe, recréée à partir du fichier XML.

configFile.Close()
Return settings
		

Le fichier est fermé et la classe est renvoyée.

Traitement

Pour ajouter des capacités de gestion de configuration à mes applications, j'ai commencé par créer un projet de bibliothèque de classes VB.NET. Ce projet était destiné à contenir les classes qui stockent les informations de configuration des applications.

Figure 4 : création d'un projet de gestion de configuration

Figure 4

Une fois ce projet créé, j'ai ajouté des classes destinées à contenir les informations de configuration réelles. Pour les exemples, j'ai créé une hiérarchie de classes destinées à contenir les paramètres de configuration. Cette hiérarchie de classes présente une classe racine, appelée Settings. Cette classe racine contient des instances d'autres classes, qui contiennent les paramètres de formulaires spécifiques. Ces classes utilisent le modèle de classe Visual Basic.NET COM pour permettre leur utilisation à partir de Visual Basic.NET ou Visual Basic 6. Pour en savoir plus sur le modèle de classe COM, reportez-vous à l'article Diagnose This (en anglais).

Liste 7 : classe Settings à la racine

‹ComClass(Settings.ClassId, Settings.InterfaceId, Settings.EventsId) › _
Public Class Settings

#Region "COM GUIDs"
    Public Const ClassId As String = "BFE852CB-EC87-4B67-AD4A-213D8A25C50F"
    Public Const InterfaceId As String = "4CBC86FE-FB0B-47EF-ADE5-7EDD8FD80B83"
    Public Const EventsId As String = "DE095353-B42B-433C-9A74-8713DC6B8A3B"
#End Region

    Public Sub New()
        MyBase.New()
    End Sub

    Private _logonForm As New LogonForm
    Public Property LogonForm() As LogonForm
        Get
            Return _logonForm
        End Get
        Set(ByVal Value As LogonForm)
            _logonForm = Value
        End Set
    End Property

    Private _imageForm As New ImageForm
    Public Property ImageForm() As ImageForm
        Get
            Return _imageForm
        End Get
        Set(ByVal Value As ImageForm)
            _imageForm = Value
        End Set
    End Property

End Class
		

Vous pouvez observer que la classe Settings contient des instances des classes LogonForm et ImageForm. Ces classes contiennent les paramètres du formulaire de connexion, ainsi que le formulaire avec l'image.

Liste 8 : classe destinée à contenir les paramètres du formulaire de connexion

‹ComClass(LogonForm.ClassId, LogonForm.InterfaceId, LogonForm.EventsId) › _
Public Class LogonForm

#Region "COM GUIDs"
    Public Const ClassId As String = "6EAC0114-F315-4CBB-8321-BCFB38A9F84D"
    Public Const InterfaceId As String = "F111DA82-C3D0-4481-A994-C254B209F228"
    Public Const EventsId As String = "EBFCD422-0A76-45F8-9813-77435949918B"
#End Region

    Public Sub New()
        MyBase.New()
    End Sub

    Private _userName As String = ""
    Public Property UserName() As String
        Get
            Return _userName
        End Get
        Set(ByVal Value As String)
            _userName = Value
        End Set
    End Property

    Private _password As String = ""
    Public Property Password() As String
        Get
            Return _password
        End Get
        Set(ByVal Value As String)
            _password = Value
        End Set
    End Property

    Private _remember As Boolean = False
    Public Property Remember() As Boolean
        Get
            Return _remember
        End Get
        Set(ByVal Value As Boolean)
            _remember = Value
        End Set
    End Property

End Class
		

Si vous examinez ces classes, vous pouvez constater qu'elles ne contiennent que de simples propriétés. Aucune logique d'application n'est présente dans ces classes. Elles constituent juste un emplacement où l'application peut stocker des informations de configuration. La dernière classe pour paramètres de configuration contient les informations du formulaire d'image.

Liste 9 : classe destinée à contenir les paramètres du formulaire d'image

‹ComClass(ImageForm.ClassId, ImageForm.InterfaceId, ImageForm.EventsId)› _
Public Class ImageForm

#Region "COM GUIDs"
    Public Const ClassId As String = "547A8B7E-FB9E-434F-91B4-40E15635AA17"
    Public Const InterfaceId As String = "5AFBD593-9076-4804-9D79-652062C12245"
    Public Const EventsId As String = "AE995B5F-5325-4071-A55C-06DFF4F0A8A7"
#End Region

    Public Sub New()
        MyBase.New()
    End Sub

    Private _width As Integer
    Public Property Width() As Integer
        Get
            Return _width
        End Get
        Set(ByVal Value As Integer)
            _width = Value
        End Set
    End Property

    Private _height As Integer
    Public Property Height() As Integer
        Get
            Return _height
        End Get
        Set(ByVal Value As Integer)
            _height = Value
        End Set
    End Property

    Private _top As Integer
    Public Property Top() As Integer
        Get
            Return _top
        End Get
        Set(ByVal Value As Integer)
            _top = Value
        End Set
    End Property

    Private _left As Integer
    Public Property Left() As Integer
        Get
            Return _left
        End Get
        Set(ByVal Value As Integer)
            _left = Value
        End Set
    End Property

    Private _picturePath As String
    Public Property PicturePath() As String
        Get
            Return _picturePath
        End Get
        Set(ByVal Value As String)
            _picturePath = Value
        End Set
    End Property

End Class
		

Les classes des informations de configuration que cette application a besoin de stocker sont ainsi terminées.

Paramètres, en entrée et en sortie

L'application doit ensuite charger et enregistrer ces classes de configuration sous forme de code XML. Pour cette tâche, j'ai créé une classe SettingsManager.

Liste 10 : classe SettingsManager

Imports System.Environment
Imports System.Xml.Serialization
Imports System.IO

‹ComClass(SettingsManager.ClassId, SettingsManager.InterfaceId, SettingsManager.EventsId) › _
Public Class SettingsManager

#Region "COM GUIDs"
    Public Const ClassId As String = "6FD6B8D1-87E8-4A1B-ABE9-20984CF41C11"
    Public Const InterfaceId As String = "2454F7C6-C5A8-4AB2-AB5F-6C6D01815337"
    Public Const EventsId As String = "00542DC3-7670-4E77-B0A5-08B9582A13F9"
#End Region

    Public Sub New()
        MyBase.New()
    End Sub

    Public Sub Save(ByVal settings As Settings, ByVal fileName As String)
        Dim xs As New XmlSerializer(GetType(Settings))
        Dim configFile As Stream = File.Open(fileName, FileMode.Create, _
            FileAccess.Write)
        xs.Serialize(configFile, settings)
        configFile.Close()
    End Sub

    Public Function Load(ByVal fileName As String) As Settings
        Dim xs As New XmlSerializer(GetType(Settings))
        Dim configFile As Stream = File.Open(fileName, FileMode.Open, _
            FileAccess.Read)
        Dim settings As Settings = xs.Deserialize(configFile)
        configFile.Close()
        Return settings
    End Function

    Public Function GetSpecialFolder(ByVal folderID As String) As String
        Dim specialFolder As SpecialFolder
        specialFolder = System.Enum.Parse(GetType(SpecialFolder), folderID)
        Return System.Environment.GetFolderPath(specialFolder)
    End Function

End Class
		

La classe SettingsManager vous permet d'enregistrer vos paramètres vers un fichier XML ou de les charger à partir d'un fichier XML. La classe SettingsManager intègre également une fonction GetSpecialFolder, que vous pouvez utiliser pour obtenir le chemin d'accès à des dossiers spéciaux comme Mes documents, Program Files, etc. La classe SettingsManager peut aussi être appelée à partir de VB.NET ou de VB6, car elle se présente également en tant qu'objet COM.

Application configurable

À ce stade, l'infrastructure de la configuration est en place. La dernière étape consiste à l'utiliser à partir de l'application.

Liste 11 : chargement des informations de configuration depuis VB6

Private SettingsFile As String

Private Sub Form_Load()
    On Error GoTo eh
    
    Dim sm As New ConfigLib.SettingsManager
    SettingsFile = sm.GetSpecialFolder("ApplicationData") & "\settings.xml"
    
    Set Settings = sm.Load(SettingsFile)
    
    With Settings.LogonForm
        txtUserName.Text = .UserName
        chkRemember.Value = IIf(.Remember, Checked, Unchecked)
        If .Remember Then
            txtPassword.Text = .Password
        End If
    End With
    
    Exit Sub

eh:
    Set Settings = New ConfigLib.Settings
End Sub
		

Dans l'événement de chargement du formulaire, l'application détermine d'abord le chemin d'accès au fichier de paramètres. Dans ce cas, l'application recherche les paramètres dans le dossier spécial ApplicationData. C'est un emplacement intéressant pour stocker des paramètres d'utilisateur, car le dossier ApplicationData est un dossier spécifique aux utilisateurs. Ainsi, les paramètres de chaque utilisateur resteront distincts. Pour obtenir la liste des dossiers spéciaux disponibles, reportez-vous à Environment.SpecialFolder Enumeration (en anglais).

Une fois que le chemin d'accès aux paramètres est déterminé, l'application crée une instance de la classe SettingsManager et l'utilise pour charger les paramètres. Ceux-ci sont chargés dans une variable Settings globale, afin d'être disponibles dans toute l'application. Les paramètres individuels sont ensuite utilisés. Par exemple, Settings.LogonForm.UserName renvoie le nom que cet utilisateur a utilisé lors de sa dernière connexion.

Si le fichier de paramètres est introuvable, un objet Settings vide est créé. L'application peut stocker le paramètre dans ce nouvel objet, dans lequel tous les paramètres seront enregistrés lorsque l'utilisateur quittera l'application.

Liste 12 : enregistrement des paramètres lorsque l'utilisateur quitte l'application VB6

Private Sub Form_Unload(Cancel As Integer)
    
    With Settings.LogonForm
        .UserName = txtUserName.Text
        .Remember = (chkRemember.Value = Checked)
        If .Remember Then
            .Password = txtPassword.Text
        End If
    End With
    
    Dim sm As New ConfigLib.SettingsManager
    sm.Save Settings, SettingsFile
End Sub
		

Lors de la fermeture du formulaire principal, les données des contrôles du formulaire sont copiées dans l'objet Settings. La classe SettingsManager est alors utilisée pour réenregistrer ces paramètres vers le disque. D'autres formulaires dans l'application récupèrent leurs paramètres dans la classe Settings lorsqu'ils sont chargés, puis stockent de nouveau leurs paramètres dans la classe Settings lorsqu'ils sont déchargés.

Qu'en est-il de App.Config ?

Si vous programmez déjà dans Visual Basic .NET, vous êtes probablement familier avec le fichier app.config. Il s'agit d'un fichier que vous pouvez ajouter à votre projet pour stocker des paramètres d'application. À première vue, vous pouvez penser que le fichier app.config répond à tous vos besoins concernant les paramètres de configuration, au moins pour les applications Visual Basic .NET. Toutefois, app.config est conçu pour certains types d'informations de configuration uniquement.

Il existe de nombreux types de données de configuration différents. Au niveau le plus bas se trouvent les informations de configuration utilisateur. Bien que la même application soit exécutée, elle peut être configurée différemment selon l'utilisateur qui l'utilise. Si l'un des utilisateurs définit des polices, des couleurs ou des tailles et des emplacements de formulaire spécifiques, ces paramètres doivent être indépendants de la configuration définie par un autre utilisateur. Les données de configuration utilisateur doivent être stockées dans un fichier distinct pour chaque utilisateur et ce fichier doit être enregistré dans le dossier spécial ApplicationData.

Des informations de configuration d'application sont également présentes. Il s'agit de données globales à l'application, indépendantes de l'utilisateur qui exécute l'application. Par exemple, l'application peut se connecter à une base de données de serveur SQL particulier, quel que soit l'utilisateur courant. S'il est prévu que la configuration de l'application puisse être modifiée par un utilisateur, alors il convient de la placer dans le dossier spécial CommonApplicationData.

Le fichier app.config peut également accueillir les paramètres globaux de l'application. En fait, certains paramètres des applications .NET doivent aller dans app.config. Par exemple, si vous souhaitez que votre application se lie à une version spécifique de .NET Framework, ou utilise une version d'une DLL plus récente que celle avec laquelle elle a été compilée, ces informations doivent être stockées dans app.config. Le problème avec app.config est qu'il doit se trouver dans le même dossier que l'exécutable de l'application. C'est-à-dire probablement sous le dossier Program Files. Les paramètres que l'utilisateur peut modifier ne doivent pas être stockés dans le dossier Program Files, car cela oblige l'utilisateur à exécuter l'application avec des privilèges administratifs. Les paramètres contenus dans app.config sont par conséquent réservés aux paramètres que seul un administrateur est susceptible de modifier.

Conclusion

Les applications ont souvent besoin de stocker et de récupérer des informations de configuration d'application ou des paramètres spécifiques aux utilisateurs. Auparavant, les paramètres d'application étaient généralement stockés dans des fichiers INI ou dans le registre système. Aujourd'hui, les fichiers XML sont le format le plus populaire pour le stockage des informations de configuration. .NET Framework simplifie le stockage et la récupération des données de configuration à partir de fichiers XML, grâce à sa capacité de sérialiser une hiérarchie d'objets au format XML, ou de recréer une hiérarchie d'objets à partir de code XML. Ceci signifie que même si les paramètres sont stockés au format XML, votre application n'a jamais besoin de traiter directement du XML et peut, au contraire, fonctionner avec des objets simples et leurs propriétés. Visual Basic .NET étant capable de créer des objets COM, ce système de configuration peut être utilisé aussi bien à partir d'applications Visual Basic 6.

Ressources supplémentaires

Scott Swigart - Biographie

Scott Swigart (http://www.swigartconsulting.com/) conseille les entreprises pour optimiser leur utilisation des technologies d'aujourd'hui et se préparer à celles de demain. Scott contribue ainsi efficacement au site VB Fusion, en proposant des informations et des tactiques d'utilisation réelle aux développeurs VB qui souhaitent construire toutes sortes de fonctionnalités le plus simplement possible. Scott est également un MVP Microsoft et co-auteur de nombreux livres et articles. Pour toute question ou tout commentaire à propos de cet article, écrivez à scott@swigartconsulting.com.

Liens utilesAutres sites Web VB

Afficher:
© 2014 Microsoft