J'ai toujours voulu écrire une classe pour exploiter des fichiers XML. J'ai cherché en ligne aujourd'hui et j'ai trouvé une classe similaire que j'avais déjà écrite, je l'ai étendue et modifiée, et finalement c'est devenu le code suivant pour la référence des novices.
//
Les événements XML sont utilisés dans cette classe. La recherche de nœuds dans cette classe doit utiliser des expressions XPath. Si vous ne comprenez pas les expressions XPath, vous pouvez consulter un autre article de ma collection : +Opération sur les fichiers XML : [Apprendre XPath]XPath. tutoriel le plus populaire +
1 utilisation du système ;
2en utilisant System.Xml ;
3en utilisant System.Web ;
4namespacesolucky
5{
6 /**//// <résumé>
7 /// L'expression XPATH doit être utilisée pour obtenir le nœud correspondant
8 /// Pour plus d'informations sur XPath, voir :
9 /// </summary>
10 classes publiques MyXml
11 {
12 Variable#région Variable
13 /**//// <résumé>
14 ///Le type de chemin où se trouve le fichier XML
15 /// </summary>
16 /// <remarks>Le type de chemin où se trouve le fichier XML</remarks>
17 énumération publique enumXmlPathType
18 {
19 /**//// <résumé>
20 /// Chemin absolu
21 /// </summary>
22Chemin Absolu,
23 /**//// <résumé>
24 /// chemin virtuel
25 /// </summary>
26Chemin Virtuel
27}
28
29 chaîne privée xmlFilePath ;
30 enumXmlPathType privé xmlFilePathType ;
31 XmlDocument privé xmlDoc = new XmlDocument();
32 #endregion
33
34
35 propriétés#propriétés de la région
36 /**//// <résumé>
37 /// Chemin du fichier
38 /// </summary>
39 /// <remarks>Chemin du fichier</remarks>
40 chaînes publiques XmlFilePath
41 {
42 obtenir
43 {
44 renvoie this.xmlFilePath ;
45 }
46 ensembles
47 {
48 xmlFilePath = valeur ;
49
50 }
51 }
52
53 /**//// <résumé>
54 /// Type de chemin de fichier
55 /// </summary>
56 public enumXmlPathType XmlFilePathTyp
57 {
58 ensembles
59 {
60 xmlFilePathType = valeur ;
61 }
62 }
63 #endregion
64
65 Constructeur #region Constructeur
66 /**//// <résumé>
67 ///
68 /// </summary>
69 /// <param name="tempXmlFilePath"></param>
70 public MyXml (chaîne tempXmlFilePath)
71 {
72 //
73 // TODO : Ajouter la logique du constructeur ici
74 //
75
76 this.xmlFilePathType = enumXmlPathType.VirtualPath ;
77 this.xmlFilePath = tempXmlFilePath;
78 GetXmlDocument();
79 //xmlDoc.Load(xmlFilePath);
80}
81
82 /**//// <résumé>
83 /// Constructeur
84 /// </summary>
85 /// <param name="tempXmlFilePath">Chemin du fichier</param>
86 /// <param name="tempXmlFilePathType">Type</param>
87 public MyXml (string tempXmlFilePath , enumXmlPathType tempXmlFilePathType )
88 {
89 //
90 // TODO : Ajouter la logique du constructeur ici
91 //
92 this.xmlFilePathType = tempXmlFilePathType;
93 this.xmlFilePath = tempXmlFilePath;
94 GetXmlDocument();
95 }
96 #endregion
97
98
99 /**////<résumé>
100 ///Obtenir la classe d'entité XmlDocument
101 ///</summary>
102 /// <returns>Une instance de document XML du fichier de description XML spécifié</returns>
103 XmlDocument privé GetXmlDocument()
104 {
105 XmlDocumentdoc=null ;
106
107 if( this.xmlFilePathType == enumXmlPathType.AbsolutePath )
108 {
109 doc = GetXmlDocumentFromFile( xmlFilePath );
110 }
111 sinon if( this.xmlFilePathType == enumXmlPathType.VirtualPath )
112 {
113 doc = GetXmlDocumentFromFile(HttpContext.Current.Server.MapPath(xmlFilePath));
114 }
115 retour doc ;
116 }
117
118 XmlDocument privé GetXmlDocumentFromFile (string tempXmlFilePath)
119 {
120 chaîne xmlFileFullPath = tempXmlFilePath ;
121 xmlDoc.Load(xmlFileFullPath);
122 //Définir le traitement des événements
123 xmlDoc.NodeChanged += new XmlNodeChangedEventHandler(this.nodeUpdateEvent);
124 xmlDoc.NodeInserted += new XmlNodeChangedEventHandler(this.nodeInsertEvent);
125 xmlDoc.NodeRemoved += new XmlNodeChangedEventHandler(this.nodeDeleteEvent);
126 renvoie xmlDoc ;
127 }
128
129 Lire la valeur d'attribut spécifiée du nœud spécifié #region Lire la valeur d'attribut spécifiée du nœud spécifié
130 /**//// <résumé>
131 /// Fonction :
132 /// Lire la valeur d'attribut spécifiée du nœud spécifié
133 /// </summary>
134 /// <param name="strNode">Nom du nœud</param>
135 /// <param name="strAttribute">Attributs de ce nœud</param>
136 /// <retours></retours>
137 chaîne publique GetXmlNodeAttributeValue(string strNode,string strAttribute)
138 {
139 chaîne strReturn = "" ;
140 essais
141 {
142 //Obtenir les nœuds selon le chemin spécifié
143 XmlNode xmlNode = xmlDoc.SelectSingleNode(strNode);
144 si (!(xmlNode==null))
145 {//Récupérez les attributs du nœud et bouclez les valeurs d'attribut requises
146 XmlAttributeCollection xmlAttr = xmlNode.Attributes;
147
148 pour (int i=0;i<xmlAttr.Count; i++)
149 {
150 si (xmlAttr.Item(i).Name == strAttribute)
151 {
152 strReturn = xmlAttr.Item(i).Value ;
153 pause ;
154 }
155 }
156 }
157 }
158 capture (XmlException XML)
159 {
160 lancers xmle ;
161 }
162 return strReturn ;
163 }
164 #endregion
165
166
167 Lire la valeur du nœud spécifié #region Lire la valeur du nœud spécifié
168 /**//// <résumé>
169 /// Fonction :
170 /// Lire la valeur du nœud spécifié
171 /// </summary>
172 /// <param name="strNode">Nom du nœud</param>
173 /// <retours></retours>
174 chaîne publique GetXmlNodeValue(string strNode)
175 {
176 chaîne strReturn = String.Empty;
177
178 essai
179 {
180 //Obtenir les nœuds en fonction du chemin
181 XmlNode xmlNode = xmlDoc.SelectSingleNode(strNode);
182 si (!(xmlNode==null))
183 strReturn = xmlNode.InnerText;
184}
185 capture (XmlException xmle)
186 {
187 lancers xmle ;
188 }
189 return strReturn ;
190 }
191 #endregion
192
193 Définir la valeur du nœud #region Définir la valeur du nœud
194 /**//// <résumé>
195 /// Fonction :
196 /// Définir la valeur du nœud
197 /// </summary>
198 /// <param name="strNode">Le nom du nœud</param>
199 /// <param name="newValue">Valeur du nœud</param>
200 public void SetXmlNodeValue (chaîne xmlNodePath, chaîne xmlNodeValue)
201 {
202 essayer
203 {
204 //Vous pouvez payer par lots pour les nœuds qui remplissent les conditions.
205 XmlNodeList xmlNode=this.xmlDoc.SelectNodes(xmlNodePath);
206 si (!(xmlNode==null))
207 {
208 foreach (XmlNode xn dans xmlNode)
209 {
210 xn.InnerText = xmlNodeValue ;
211 }
212 }
213 /**//*
214 * Obtenir les nœuds selon le chemin spécifié
215 XmlNode xmlNode = xmlDoc.SelectSingleNode(xmlNodePath);
216 //Définir la valeur du nœud
217 si (!(xmlNode==null))
218 xmlNode.InnerText = xmlNodeValue;*/
219 }
220 capture (XmlException xmle)
221 {
222 jets xmle ;
223 }
224 }
225 #endregion
226
227 Définir la valeur d'attribut du nœud #region Définir la valeur d'attribut du nœud
228 /**//// <résumé>
229 /// Fonction :
230 ///Définir la valeur d'attribut du nœud
231 /// </summary>
232 /// <param name="xmlNodePath">Nom du nœud</param>
233 /// <param name="xmlNodeAttribute">Nom de l'attribut</param>
234 /// <param name="xmlNodeAttributeValue">Valeur de l'attribut</param>
235 public void SetXmlNodeAttributeValue(string xmlNodePath,string xmlNodeAttribute,string xmlNodeAttributeValue)
236 {
237 essayer
238 {
239 //Vous pouvez payer les attributs des nœuds qualifiés par lots
240 XmlNodeList xmlNode=this.xmlDoc.SelectNodes(xmlNodePath);
241 si (!(xmlNode==null))
242 {
243 foreach (XmlNode xn dans xmlNode)
244 {
245 XmlAttributeCollection xmlAttr = xn.Attributes ;
246 pour (int i=0; i<xmlAttr.Count; i++)
247 {
248 si ( xmlAttr.Item(i).Name == xmlNodeAttribute )
249 {
250 xmlAttr.Item(i).Value = xmlNodeAttributeValue ;
251 pause ;
252 }
253 }
254 }
255 }
256 /**//*Nœud unique
257 //Obtenir les nœuds selon le chemin spécifié
258 XmlNode xmlNode = xmlDoc.SelectSingleNode(xmlNodePath);
259 si (!(xmlNode==null))
260 {//Obtenir les attributs du nœud et boucler les valeurs d'attribut requises
261 XmlAttributeCollection xmlAttr = xmlNode.Attributes;
262 pour (int i=0; i<xmlAttr.Count; i++)
263 {
264 si ( xmlAttr.Item(i).Name == xmlNodeAttribute )
265 {
266 xmlAttr.Item(i).Value = xmlNodeAttributeValue ;
267 pause ;
268 }
269 }
270 }
271 */
272 }
273 capture (XmlException xmle)
274 {
275 lancers xmle ;
276 }
277 }
278 #endregion
279
280 Ajouter une #région Ajouter
281 /**//// <résumé>
282 /// Récupère l'élément racine du fichier XML
283 /// </summary>
284 XmlNode public GetXmlRoot()
285 {
286 renvoie xmlDoc.DocumentElement ;
287 }
288
289 /**//// <résumé>
290 /// Ajouter un nœud parent sous le nœud racine
291 /// </summary>
292 public void AddParentNode (string parentNode)
293 {
294 essai
295 {
296 Racine XmlNode = GetXmlRoot();
297 XmlNode parentXmlNode = xmlDoc.CreateElement(parentNode);
298 root.AppendChild(parentXmlNode);
299 }
300 captures (XmlException xmle)
301 {
302 lancer xmle ;
303 }
304 }
305
306 /**//// <résumé>
307 /// Insérer un nœud enfant dans un nœud parent existant
308 /// </summary>
309 /// <param name="parentNodePath">Nœud parent</param>
310 /// <param name="childNodePath">nom du point d'octet</param>
311 public void AddChildNode(string parentNodePath,string childnodename)
312 {
313 essayer
314 {
315 XmlNode parentXmlNode = xmlDoc.SelectSingleNode(parentNodePath);
316 if(!((parentXmlNode)==null))//Si ce nœud existe
317 {
318 XmlNode childXmlNode = xmlDoc.CreateElement(childnodename);
319 parentXmlNode.AppendChild( childXmlNode );
320 }
321 else{//S'il n'existe pas, ajoutez le nœud parent
322 //this.GetXmlRoot().AppendChild(childXmlNode);
323 }
324
325 }
326 capture (XmlException xmle)
327 {
328 jets xmle ;
329 }
330 }
331
332 /**//// <résumé>
333 /// Ajouter des attributs à un nœud
334 /// </summary>
335 /// <param name="NodePath">Chemin du nœud</param>
336 /// <param name="NodeAttribute">Nom de l'attribut</param>
337 public void AddAttribute(string NodePath, string NodeAttribute)
338 {
339 privateAddAttribute(NodePath,NodeAttribute,"");
340 }
341 /**//// <résumé>
342 ///
343 /// </summary>
344 /// <param name="NodePath"></param>
345 /// <param name="NodeAttribute"></param>
346 /// <param name="NodeAttributeValue"></param>
347 private void privateAddAttribute (string NodePath, string NodeAttribute, string NodeAttributeValue)
348 {
349 essai
350 {
351 XmlNode nodePath = xmlDoc.SelectSingleNode(NodePath);
352 si (!(nodePath==null))
353 {
354 XmlAttribute nodeAttribute = this.xmlDoc.CreateAttribute(NodeAttribute);
355 nodeAttribute.Value=NodeAttributeValue ;
356 nodePath.Attributes.Append(nodeAttribute);
357 }
358 }
359 capture (XmlException XML)
360 {
361 lancer xmle ;
362 }
363 }
364 /**//// <résumé>
365 /// Ajouter des attributs à un nœud et payer une valeur
366 /// </summary>
367 /// <param name="NodePath">Nœud</param>
368 /// <param name="NodeAttribute">Nom de l'attribut</param>
369 /// <param name="NodeAttributeValue">Valeur de l'attribut</param>
370 public void AddAttribute (string NodePath, string NodeAttribute, string NodeAttributeValue)
371 {
372 privateAddAttribute(NodePath,NodeAttribute,NodeAttributeValue);
373 }
374 #endregion
375
376 Supprimer la #région Supprimer
377 /**//// <résumé>
378 /// Supprimer un attribut du nœud
379 /// </summary>
380 /// <param name="NodePath">expression xpath où se trouve le nœud</param>
381 /// <param name="NodeAttribute">Nom de l'attribut</param>
382 public void DeleteAttribute (string NodePath, string NodeAttribute)
383 {
384 XmlNodeList nodePath =this.xmlDoc.SelectNodes(NodePath);
385 si (!(nodePath==null))
386 {
387 foreach (tempxn XmlNode dans nodePath)
388 {
389 XmlAttributeCollection xmlAttr = tempxn.Attributes;
390 pour (int i=0; i<xmlAttr.Count; i++)
391 {
392 si (xmlAttr.Item(i).Name == NodeAttribute)
393 {
394 tempxn.Attributes.RemoveAt(i);
395 pause ;
396 }
397 }
398 }
399 }
400 }
401
402 /**//// <résumé>
403 /// Supprime un nœud lorsque sa valeur d'attribut est égale à la valeur donnée
404 /// </summary>
405 /// <param name="NodePath">expression xpath où se trouve le nœud</param>
406 /// <param name="NodeAttribute">Attribut</param>
407 /// <param name="NodeAttributeValue">valeur</param>
408 public void DeleteAttribute (string NodePath, string NodeAttribute, string NodeAttributeValue)
409 {
410 XmlNodeList nodePath =this.xmlDoc.SelectNodes(NodePath);
411 si (!(nodePath==null))
412 {
413 foreach (tempxn XmlNode dans nodePath)
414 {
415 XmlAttributeCollection xmlAttr = tempxn.Attributes;
416 pour (int i=0; i<xmlAttr.Count; i++)
417 {
418 si (xmlAttr.Item(i).Name == NodeAttribute && xmlAttr.Item(i).Value==NodeAttributeValue)
419 {
420 tempxn.Attributes.RemoveAt(i);
421 pause ;
422 }
423 }
424 }
425 }
426 }
427 /**//// <résumé>
428 /// Supprimer le nœud
429 /// </summary>
430 /// <param name="tempXmlNode"></param>
431 /// <remarques></remarques>
432 public void DeleteXmlNode(string tempXmlNode){
433 XmlNodeList nodePath =this.xmlDoc.SelectNodes(tempXmlNode);
434 si (!(nodePath==null))
435 {
436 foreach (XmlNode xn dans nodePath)
437 {
438 xn.ParentNode.RemoveChild(xn);
439 }
440 }
441 }
442
443 #endregion
444
445 Événement de document XML#région Événement de document XML
446 /**//// <résumé>
447 ///
448 /// </summary>
449 /// <param name="src"></param>
450 /// <param name="args"></param>
451 private void nodeInsertEvent (Object src, XmlNodeChangedEventArgs args)
452 {
453 //Enregistrer les paramètres
454 SaveXmlDocument();
455 }
456 /**//// <résumé>
457 ///
458 /// </summary>
459 /// <param name="src"></param>
460 /// <param name="args"></param>
461 private void nodeDeleteEvent (Object src, XmlNodeChangedEventArgs args)
462 {
463 //Enregistrer les paramètres
464 SaveXmlDocument();
465 }
466 /**//// <résumé>
467 ///
468 /// </summary>
469 /// <param name="src"></param>
470 /// <param name="args"></param>
471 private void nodeUpdateEvent (Object src, XmlNodeChangedEventArgs args)
472 {
473 //Enregistrer les paramètres
474 SaveXmlDocument();
475 }
476 #endregion
477
478 Enregistrer le fichier XML #region Enregistrer le fichier XML
479 /**//// <résumé>
480 /// Fonction :
481 /// Enregistrer le fichier XML
482 ///
483 /// </summary>
484 public void SaveXmlDocument()
485 {
486 essai
487 {
488 //Enregistrer les résultats des paramètres
489 if( this.xmlFilePathType == enumXmlPathType.AbsolutePath )
490 {
491 Savexml(xmlFilePath);
492 }
493 sinon if( this.xmlFilePathType == enumXmlPathType.VirtualPath )
494 {
495 Savexml(HttpContext.Current.Server.MapPath(xmlFilePath));
496 }
497 }
498 capture (XmlException xmle)
499 {
500 lancers XML ;
501 }
502 }
503
504 /**//// <résumé>
505 /// Fonction :
506 /// Enregistrer le fichier XML
507 /// </summary>
508 public void SaveXmlDocument (chaîne tempXMLFilePath)
509 {
510 essai
511 {
512 //Enregistrer les résultats des paramètres
513 Savexml(tempXMLFilePath);
514 }
515 capture (XmlException xmle)
516 {
517 lancer XML ;
518 }
519 }
520 /**//// <résumé>
521 ///
522 /// </summary>
523 /// <param name="filepath"></param>
524 vide privé Savexml (chemin de fichier de chaîne)
525 {
526 xmlDoc.Save(chemin du fichier);
527 }
528
529 #endregion
530
531 }
532
533}
534
535