[C#] Problème pour lire un fichier xml

**LE NEINDRE** · 21/06/2006, 16h07

Bonjour à tous !

J'ai le fichier xml (très simple et qui ne change pas) suivant:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
<?xml version="1.0" encoding="utf-8" ?>
<Settings>
	<Local_Directory>
		<Directory>
			yeahhhh
		</Directory>
	</Local_Directory>
	<Account>
		<Username>
 
		</Username>
		<Password>
 
		</Password>
		<Url>
 
		</Url>
	</Account>
	<Options>
		<Mode>
 
		</Mode>
		<Automate>
			<Automatic>
 
			</Automatic>
			<Everyday>
 
			</Everyday>
			<Specific>
 
			</Specific>
		</Automate>
	</Options>
</Settings>

Je voudrais savoir quelle est la solution la plus simple pour lire ce fichier...
Dois-je utiliser un dataset ?
Existe t'il des méthodes simples pour lire un noeud et écrire dans un noeud...

Merci pour votre aide !!!!!

**AlexandreP** · 21/06/2006, 16h34

Je ne me souviens plus du post dans lequel ce problème a été traité, mais j'utilise ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
 
namespace XML_RW
        {
            /// <summary>
            /// Class use to read config xml file
            /// </summary>
            public class ConfigReaderWriter
            {
                #region Private declaration
                /// <summary>
                /// Path to config file
                /// </summary>
                private static string CONFIG_FILE;
                /// <summary>
                /// XML text reader
                /// </summary>
                private XmlTextReader LecteurXml = null;
                /// <summary>
                /// File stream to load xmlreader
                /// </summary>
                private FileStream StreamFichier = null;
                /// <summary>
                /// error message
                /// </summary>
                private string _errMsg;
                #endregion
 
                #region Get/Set Methods
                /// <summary>
                /// Represent an error message
                /// </summary>
                /// <value>Get the _errMsg</value>
                public string errMsg
                {
                    get
                    { return _errMsg; }
                }
                #endregion
 
                #region Constructor
                /// <summary>
                /// Constructor
                /// </summary>
                /// <param name="chemin">Path to config file</param>
                public ConfigReaderWriter(string chemin)
                {
                    CONFIG_FILE = chemin;
                    _errMsg = "";
                }
                #endregion
 
                #region Private method
                // Method used to load xml config file
                /// <summary>
                /// Method used to load xml config file
                /// </summary>
                /// <returns>The XMLTextReader</returns>
                private XmlTextReader ReadConfig()
                {
                    try
                    {
                        StreamFichier = new FileStream(CONFIG_FILE, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite);
                        LecteurXml = new XmlTextReader(StreamFichier);
                    }
                    catch (IOException ex)
                    {
                        _errMsg = ex.Message;
                    }
 
                    return LecteurXml;
                }
                #endregion
 
                #region Public method
                // Method used to close xml file
                /// <summary>
                /// Close the xml file
                /// </summary>
                public void Close()
                {
                    if (LecteurXml != null)
                    {
                        LecteurXml.Close();
                    }
 
                    if (StreamFichier != null)
                    {
                        StreamFichier.Close();
                    }
                }
 
                // Return the asked value
                /// <summary>
                /// Get a specific value
                /// </summary>
                /// <param name="ElementName">Element name to find</param>
                /// <returns>Value find</returns>
                public string GetXmlValue(string ElementName)
                {
                    string Value = null;
                    XmlTextReader XmlReader = null;
 
                    try
                    {
                        // Lecture du fichier de configuation
                        XmlReader = ReadConfig();
 
                        // Tant que l'on peut lire
                        while (XmlReader.Read())
                        {
                            // On récupère le type de noeud actuel
                            XmlNodeType NodeType = XmlReader.NodeType;
 
                            // Si c'est un élément
                            if (NodeType == XmlNodeType.Element)
                            {
                                // et qu'il vaut "add" et que la valeur de "key" est égale à celle passée en paramètre
                                if (XmlReader.Name.Equals("add") && XmlReader.GetAttribute("key").Equals(ElementName))
                                {
                                    // On récupère la valeur de cet élément
                                    Value = XmlReader.GetAttribute("value");
                                    // On ferme alors le XmlTextReader
                                    XmlReader.Close();
 
                                    // On retourne la valeur que l'on vient de trouver
                                    return Value;
                                }
                            }
                        }
                    }
                    catch (XmlException ex)
                    {
                        _errMsg = ex.Message;
                    }
                    finally
                    {
                        // Fermeture de XmlReader qui a chargé le fichier de configuration
                        if (XmlReader != null)
                        {
                            XmlReader.Close();
                        }
                    }
 
                    return Value;
                }
 
                // Set a specific value
                /// <summary>
                /// Set a specific value
                /// </summary>
                /// <param name="ElementName">Element name to modify/create</param>
                /// <param name="sValue">Value to apply</param>
                public void SetXmlValue(string ElementName, string sValue)
                {
                    XmlTextReader XmlReader = null;
                    XmlDocument XmlWritter = null;
 
                    try
                    {
                        // Lecture du fichier de configuation
                        XmlReader = ReadConfig();
 
                        // Tant que l'on peut lire
                        while (XmlReader.Read())
                        {
                            // On récupère le type de noeud actuel
                            XmlNodeType NodeType = XmlReader.NodeType;
 
                            // Si c'est un élément
                            if (NodeType == XmlNodeType.Element)
                            {
 
                                // Si le nom vaut "add" et que la valeur de "key" est égale à celle passée en paramètre
                                if (XmlReader.Name.Equals("add") && XmlReader.GetAttribute("key").Equals(ElementName))
                                {
                                    // On libère les ressources (fichier de config)
                                    this.Close();
 
                                    // On charge le fichier de config dans un XmlDocument
                                    XmlWritter = new XmlDocument();
                                    XmlWritter.Load(CONFIG_FILE);
 
                                    XmlElement ElementRacine = XmlWritter.DocumentElement;
 
                                    XmlAttribute AttributXml = null;
                                    XmlNode sectionNode = null;
 
                                    XmlNode groupNode = ElementRacine;
 
                                    // On recherche les Nodes du nom de "add"
                                    sectionNode = groupNode.SelectSingleNode("appSettings");
 
                                    // Si on ne trouve pas cette nom, on la rajoute
                                    if (sectionNode == null)
                                    {
                                        sectionNode = groupNode.AppendChild(XmlWritter.CreateElement("appSettings"));
                                    }
 
                                    // On recherche ensuite la clé ayant dont le nom est passé en parmètre
                                    XmlNode NodeCherche = sectionNode.SelectSingleNode("add[@key=\"" + ElementName + "\"]");
 
                                    // Si cette clé n'existe pas, on la rajoute
                                    if (NodeCherche == null)
                                    {
                                        XmlElement element = XmlWritter.CreateElement("add");
                                        AttributXml = XmlWritter.CreateAttribute("key");
                                        AttributXml.Value = ElementName;
                                        element.Attributes.Append(AttributXml);
 
                                        NodeCherche = sectionNode.AppendChild(element);
                                    }
 
                                    // On créé l'attribut value et on lui assigne la valeur passée en paramètre
                                    AttributXml = XmlWritter.CreateAttribute("value");
                                    AttributXml.Value = sValue.ToString();
                                    NodeCherche.Attributes.Append(AttributXml);
 
                                    // Enregistrement du fichier
                                    XmlWritter.Save(CONFIG_FILE);
                                }
                            }
                        }
                    }
                    catch (XmlException ex)
                    {
                        _errMsg = ex.Message;
                    }
                    catch (Exception ex)
                    {
                        _errMsg = ex.Message;
                    }
                    finally
                    {
                        // Fermeture de XmlReader qui a chargé le fichier de configuration (dans le cas où il ne serait pas déjà fermé)
                        if (XmlReader != null)
                        {
                            XmlReader.Close();
                        }
                    }
                }
 
                #endregion
            }
        }

Il y a bien sûr des choses à modifier, mais ça marche plutot bien.
Le principe est là.

**murlock** · 21/06/2006, 16h38

Tu peux directement utiliser

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
XmlDocument xml_doc;
StreamReader xml_file = File.OpenText("monfichier.xml");
xml_doc.Load(xml_file);
xml_file.Close();

et ensuite tu peux utiliser XPath pour extraire les informations :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
XmlNodeList nodelist = xml_doc.SelectNodes( "/settings/account" );
foreach( XmlNode n in nodelist ) {
Console.WriteLine( "> " + n.InnerText );
}

ou ajouter des nodes

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
XmlNode account= xml_doc.SelectSingleNode("/settings/account");
 
XmlElement user = xml_doc.CreateElement("Username");
user.InnerText = "totor";
account.AppendChild(user);

**LE NEINDRE** · 21/06/2006, 16h48

Merci LeGars pour ta réponse !!!

Je crois que je vais suivre Murlock car sa solution est super pour mon petit fichier !!!
J'avais utilisée cette méthode pour lire un autre fichier xml mais visiblement, je l'avais mal comprise ...

Merci beaucoup Murlock !!!

**LE NEINDRE** · 22/06/2006, 14h40

J'ai tout de même un problème pour enregistrer mes changements ...

Voilà ce que j'ai fait:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
 
    class XMLSettings
    {
        private string my_xml_file = "./Settings.xml";
        private XmlDocument xml_doc = new XmlDocument();
        private StreamReader str;
        //Noeud Local_Directory
        public string xml_local_directory;
 
        //Noeud Account
        private string xml_user;
        private string xml_password;
        private string xml_url;
 
        //Noeud Options
        private string xml_mode;
 
        //Noeud Automate
        private string xml_automate;
 
        //Constructeur
        //Load du fichier xml
        public XMLSettings()
        {
 
            try{this.str = File.OpenText("..\\..\\" + this.my_xml_file);}
            catch (Exception e) { new Error("Error while loading settings",e.Message); }
            try { xml_doc.Load(str); }
            catch (Exception e) { new Error("Error while loading settings", e.Message); }
            str.Close();
            this.xml_local_directory = xml_doc.SelectNodes("/Settings/Local_Directory/Directory").Item(0).InnerText.Trim();
            this.xml_user = xml_doc.SelectNodes("/Settings/Account/Username").Item(0).InnerText.Trim();
            this.xml_password = xml_doc.SelectNodes("/Settings/Account/Password").Item(0).InnerText.Trim();
            this.xml_url = xml_doc.SelectNodes("/Settings/Account/Url").Item(0).InnerText.Trim();
            this.xml_mode = xml_doc.SelectNodes("/Settings/Options/Mode").Item(0).InnerText.Trim();
            this.xml_automate = xml_doc.SelectNodes("/Settings/Options/Automate").Item(0).InnerText.Trim();
 
        }
 
        // Définition Accesseurs (get,set)
        public string LocalDirectory
        {
            get { return this.xml_local_directory; }
            set {xml_local_directory = value; }
        }
        public string Username
        {
            get { return this.xml_user; }
            set { xml_user = value; }
        }
        public string Password
        {
            get { return this.xml_password; }
            set { this.xml_password = value; }
        }
        public string Url
        {
            get {return this.xml_url;}
            set {this.xml_url = value;}
        }
        public string Mode
        {
            get { return this.xml_mode; }
            set { this.xml_mode = value; }
        }
        public string Automate
        {
            get { return this.xml_automate; }
            set { this.xml_automate = value; }
        }
 
        public void SaveSettings()
        {
            MessageBox.Show(this.xml_local_directory);
            xml_doc.SelectSingleNode("/Settings/Local_Directory/Directory").InnerText=this.xml_local_directory;
            xml_doc.SelectNodes("/Settings/Account/Username").Item(0).InnerText=this.xml_user;
            xml_doc.SelectNodes("/Settings/Account/Password").Item(0).InnerText=this.xml_password;
            xml_doc.SelectNodes("/Settings/Account/Url").Item(0).InnerText=this.xml_mode;
            xml_doc.SelectNodes("/Settings/Options/Mode").Item(0).InnerText=this.xml_mode;
            xml_doc.SelectNodes("/Settings/Options/Automate").Item(0).InnerText=this.xml_automate;
            xml_doc.Save(my_xml_file);
 
        }
    }
}

Lorsque j'appelle la fonction SaveSettings(), je n'ai pas d'erreur mais mon fichier n'a pas changé !!

**LE NEINDRE** · 22/06/2006, 15h20

ralala,

j'ai été pas vu que je savait pas dans le bon fichier ....

C'est bon, ça fonctionne avec la methode Save();

**murlock** · 22/06/2006, 23h07

Petite réponse pour dire que :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
xml_doc.SelectNodes("/Settings/Options/Automate").Item(0)

peut être avantageusement remplacé par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
xml_doc.SelectSingleNode("/Settings/Options/Automate")

puisque tu n'attends qu'un seul élément...

Personnellement, j'aurais mis ça en attribut pour éviter un jour d'avoir plusieurs fils Automate par exemple... mais ça dépend parfois du contenu de l'élément (un CDATA par exemple) ou du fournisseur.

[C#] Problème pour lire un fichier xml

Windows Forms

Vue hybride

Discussions similaires

Partager

Partager