Siempre quise escribir una clase para operar archivos XML. Hoy busqué en línea y encontré una clase similar que ya había escrito, la amplié y modifiqué, y finalmente se convirtió en el siguiente código para referencia de los principiantes.
//
Los eventos XML se utilizan en esta clase. La búsqueda de nodos en esta clase debe utilizar expresiones xpath. Si no comprende las expresiones xpath, puede consultar otro artículo de mi colección: + Operación de archivo XML: [Aprendiendo xpath] XPath. tutorial más popular +
1 uso del sistema;
2usando System.Xml;
3usando System.Web;
4namespaceslucky
5{
6 /**//// <resumen>
7 /// Se debe utilizar la expresión XPATH para obtener el nodo correspondiente
8 /// Para obtener información sobre xpath, consulte:
9 /// </summary>
10 clases públicas MyXml
11 {
12 Variable#región Variable
13 /**//// <resumen>
14 /// El tipo de ruta donde se encuentra el archivo xml
15 /// </summary>
16 /// <remarks>El tipo de ruta donde se encuentra el archivo xml</remarks>
17 enumeración pública enumXmlPathType
18 {
19 /**//// <resumen>
20 /// Camino absoluto
21 /// </summary>
22Camino Absoluto,
23 /**//// <resumen>
24 /// camino virtual
25 /// </summary>
26Ruta Virtual
27}
28
29 cadena privada xmlFilePath;
30 enumXmlPathType privado xmlFilePathType;
31 XmlDocument privado xmlDoc = nuevo XmlDocument();
32 #endregion
33
34
35 propiedades#propiedades de región
36 /**//// <resumen>
37 /// Ruta del archivo
38 /// </summary>
39 /// <remarks>Ruta del archivo</remarks>
40 cadena pública XmlFilePath
41 {
42 obtener
43 {
44 devolver this.xmlFilePath;
45 }
46 juegos
47 {
48 xmlFilePath = valor;
49
50 }
51 }
52
53 /**//// <resumen>
54 /// Tipo de ruta del archivo
55 /// </summary>
56 enumeración públicaXmlPathType XmlFilePathTyp
57 {
58 conjuntos
59 {
60 xmlFilePathType = valor;
61 }
62 }
63 #regiónfinal
64
65 Constructor #región Constructor
66 /**//// <resumen>
67 ///
68 /// </summary>
69 /// <param nombre="tempXmlFilePath"></param>
70 MyXml público (cadena tempXmlFilePath)
71 {
72 //
73 // TODO: Agregar lógica de constructor aquí
74 //
75
76 this.xmlFilePathType = enumXmlPathType.VirtualPath;
77 this.xmlFilePath = tempXmlFilePath;
78 GetXmlDocumento();
79 //xmlDoc.Load(xmlFilePath);
80}
81
82 /**//// <resumen>
83 /// Constructor
84 /// </summary>
85 /// <param name="tempXmlFilePath">Ruta del archivo</param>
86 /// <param name="tempXmlFilePathType">Tipo</param>
87 MyXml público (cadena tempXmlFilePath, enumXmlPathType tempXmlFilePathType)
88 {
89 //
90 // TODO: Agregar lógica de constructor aquí
91 //
92 this.xmlFilePathType = tempXmlFilePathType;
93 this.xmlFilePath = tempXmlFilePath;
94 GetXmlDocumento();
95 }
96 #endregion
97
98
99 /**////<resumen>
100 /// Obtener la clase de entidad XmlDocument
101 ///</summary>
102 /// <returns>Una instancia de documento xml del archivo de descripción XML especificado</returns>
103 Documento Xml privado GetXmlDocument()
104 {
105 Documento Xml doc=null;
106
107 si (this.xmlFilePathType == enumXmlPathType.AbsolutePath)
108 {
109 documento = GetXmlDocumentFromFile( xmlFilePath );
110 }
111 más si (this.xmlFilePathType == enumXmlPathType.VirtualPath)
112 {
113 documento = GetXmlDocumentFromFile(HttpContext.Current.Server.MapPath(xmlFilePath));
114 }
115 documento de devolución;
116 }
117
118 XmlDocument privado GetXmlDocumentFromFile (cadena tempXmlFilePath)
119 {
120 cadenas xmlFileFullPath = tempXmlFilePath;
121 xmlDoc.Load(xmlFileFullPath);
122 //Definir procesamiento de eventos
123 xmlDoc.NodeChanged += nuevo XmlNodeChangedEventHandler(this.nodeUpdateEvent);
124 xmlDoc.NodeInserted += nuevo XmlNodeChangedEventHandler(this.nodeInsertEvent);
125 xmlDoc.NodeRemoved += nuevo XmlNodeChangedEventHandler(this.nodeDeleteEvent);
126 devolver documento xml;
127 }
128
129 Leer el valor de atributo especificado del nodo especificado #región Leer el valor de atributo especificado del nodo especificado
130 /**//// <resumen>
131 /// Función:
132 /// Leer el valor del atributo especificado del nodo especificado
133 /// </summary>
134 /// <param name="strNode">Nombre de nodo</param>
135 /// <param name="strAttribute">Atributos de este nodo</param>
136 /// <devoluciones></devoluciones>
137 cadena pública GetXmlNodeAttributeValue (cadena strNode, cadena strAttribute)
138 {
139 cadena strReturn = "";
140 intento
141 {
142 //Obtener nodos según la ruta especificada
143 XmlNode xmlNode = xmlDoc.SelectSingleNode(strNode);
144 si (!(xmlNode==null))
145 {//Obtener los atributos del nodo y generar un bucle con los valores de atributo requeridos
146 XmlAttributeCollection xmlAttr = xmlNode.Attributes;
147
148 para(int i=0;i<xmlAttr.Count; i++)
149 {
150 si (xmlAttr.Item(i).Nombre == strAttribute)
151 {
152 strReturn = xmlAttr.Item(i).Value;
153 descanso;
154 }
155 }
156 }
157 }
158 captura (XmlException xmle)
159 {
xml de 160 tiros;
161 }
162 retorno strReturn;
163 }
164 #regiónfinal
165
166
167 Leer el valor del nodo especificado #region Leer el valor del nodo especificado
168 /**//// <resumen>
169 /// Función:
170 /// Leer el valor del nodo especificado
171 /// </summary>
172 /// <param name="strNode">Nombre de nodo</param>
173 /// <devoluciones></devoluciones>
174 cadena pública GetXmlNodeValue (cadena strNode)
175 {
176 cadena strReturn = String.Empty;
177
178 intento
179 {
180 //Obtener nodos según la ruta
181 XmlNode xmlNode = xmlDoc.SelectSingleNode(strNode);
182 si (!(xmlNode==null))
183 strReturn = xmlNode.InnerText;
184}
185 captura (XmlException xmle)
186 {
187 tiro xmle;
188 }
189 retorno strReturn;
190 }
191 #endregion
192
193 Establecer valor de nodo #región Establecer valor de nodo
194 /**//// <resumen>
195 /// Función:
196 /// Establecer valor de nodo
197 /// </summary>
198 /// <param name="strNode">El nombre del nodo</param>
199 /// <param name="newValue">Valor de nodo</param>
200 público vacío SetXmlNodeValue (cadena xmlNodePath, cadena xmlNodeValue)
201 {
202 intento
203 {
204 //Puedes pagar en lotes por los nodos que cumplan las condiciones.
205 XmlNodeList xmlNode=this.xmlDoc.SelectNodes(xmlNodePath);
206 si (!(xmlNode==null))
207 {
208 foreach(XmlNode xn en xmlNode)
209 {
210 xn.InnerText = xmlNodeValue;
211 }
212 }
213 /**//*
214 * Obtener nodos según la ruta especificada
215 XmlNode xmlNode = xmlDoc.SelectSingleNode(xmlNodePath);
216 //Establecer valor de nodo
217 si (!(xmlNode==null))
218 xmlNode.InnerText = xmlNodeValue;*/
219 }
220 captura (XmlException xmle)
221 {
222 tiro xmle;
223 }
224 }
225 #endregion
226
227 Establecer el valor del atributo del nodo #region Establecer el valor del atributo del nodo
228 /**//// <resumen>
229 /// Función:
230 /// Establecer el valor del atributo del nodo
231 /// </summary>
232 /// <param name="xmlNodePath">Nombre de nodo</param>
233 /// <param name="xmlNodeAttribute">Nombre del atributo</param>
234 /// <param name="xmlNodeAttributeValue">Valor del atributo</param>
235 público vacío SetXmlNodeAttributeValue (cadena xmlNodePath, cadena xmlNodeAttribute, cadena xmlNodeAttributeValue)
236 {
237 intento
238 {
239 //Puedes pagar atributos de nodos calificados en lotes
240 XmlNodeList xmlNode=this.xmlDoc.SelectNodes(xmlNodePath);
241 si (!(xmlNode==null))
242 {
243 foreach(XmlNode xn en xmlNode)
244 {
245 XmlAttributeCollection xmlAttr = xn.Atributos;
246 para(int i=0; i<xmlAttr.Count; i++)
247 {
248 si (xmlAttr.Item(i).Name == xmlNodeAttribute)
249 {
250 xmlAttr.Item(i).Value = xmlNodeAttributeValue;
251 descanso;
252 }
253 }
254 }
255 }
256 /**//*Nodo único
257 //Obtener nodos según la ruta especificada
258 XmlNode xmlNode = xmlDoc.SelectSingleNode(xmlNodePath);
259 si (!(xmlNode==null))
260 {//Obtener los atributos del nodo y generar un bucle con los valores de atributo requeridos
261 XmlAttributeCollection xmlAttr = xmlNode.Attributes;
262 para(int i=0; i<xmlAttr.Count; i++)
263 {
264 si (xmlAttr.Item(i).Name == xmlNodeAttribute)
265 {
266 xmlAttr.Item(i).Value = xmlNodeAttributeValue;
267 descanso;
268 }
269 }
270 }
271 */
272 }
273 captura (XmlException xmle)
274 {
275 tiro xmle;
276 }
277 }
278 #endregion
279
280 Agregar #región Agregar
281 /**//// <resumen>
282 /// Obtener el elemento raíz del archivo XML
283 /// </summary>
284 público XmlNode GetXmlRoot()
285 {
286 devolver xmlDoc.DocumentElement;
287 }
288
289 /**//// <resumen>
290 /// Agregar un nodo principal debajo del nodo raíz
291 /// </summary>
292 público vacío AddParentNode (cadena parentNode)
293 {
294 intento
295 {
296 Raíz de XmlNode = GetXmlRoot();
297 XmlNode parentXmlNode = xmlDoc.CreateElement(parentNode);
298 raíz.AppendChild(parentXmlNode);
299 }
300 captura (XmlException xmle)
301 {
302 tiro xmle;
303 }
304 }
305
306 /**//// <resumen>
307 /// Insertar un nodo secundario en un nodo principal existente
308 /// </summary>
309 /// <param name="parentNodePath">Nodo principal</param>
310 /// <param name="childNodePath">nombre del punto de byte</param>
311 public void AddChildNode (cadena parentNodePath, cadena childnodename)
312 {
313 intento
314 {
315 XmlNode parentXmlNode = xmlDoc.SelectSingleNode(parentNodePath);
316 if(!((parentXmlNode)==null))//Si este nodo existe
317 {
318 XmlNode childXmlNode = xmlDoc.CreateElement(childnodename);
319 parentXmlNode.AppendChild(niñoXmlNode);
320 }
321 else{//Si no existe, agregue el nodo principal
322 //this.GetXmlRoot().AppendChild(childXmlNode);
323 }
324
325 }
326 captura (XmlException xmle)
327 {
328 tiro xmle;
329 }
330 }
331
332 /**//// <resumen>
333 /// Agregar atributos a un nodo
334 /// </summary>
335 /// <param name="NodePath">Ruta del nodo</param>
336 /// <param name="NodeAttribute">Nombre del atributo</param>
337 AddAttribute público vacío (cadena NodePath, cadena NodeAttribute)
338 {
339 privateAddAttribute(NodePath,NodeAttribute,"");
340 }
341 /**//// <resumen>
342 ///
343 /// </summary>
344 /// <param nombre="NodePath"></param>
345 /// <param nombre="NodeAttribute"></param>
346 /// <param nombre="NodeAttributeValue"></param>
347 privado vacío privateAddAttribute (cadena NodePath, cadena NodeAttribute, cadena NodeAttributeValue)
348 {
349 intento
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 captura (XmlException xmle)
360 {
361 tiro xmle;
362 }
363 }
364 /**//// <resumen>
365 /// Agregar atributos a un nodo y pagar valor
366 /// </summary>
367 /// <param name="NodePath">Nodo</param>
368 /// <param name="NodeAttribute">Nombre del atributo</param>
369 /// <param name="NodeAttributeValue">Valor del atributo</param>
370 AddAttribute público vacío (cadena NodePath, cadena NodeAttribute, cadena NodeAttributeValue)
371 {
372 privateAddAttribute(NodePath,NodeAttribute,NodeAttributeValue);
373 }
374 #endregion
375
376 Eliminar #región Eliminar
377 /**//// <resumen>
378 /// Eliminar un atributo del nodo
379 /// </summary>
380 /// <param name="NodePath">expresión xpath donde se encuentra el nodo</param>
381 /// <param name="NodeAttribute">Nombre del atributo</param>
382 public void DeleteAttribute (cadena NodePath, cadena NodeAttribute)
383 {
384 XmlNodeList nodePath =this.xmlDoc.SelectNodes(NodePath);
385 si (!(nodePath==null))
386 {
387 foreach (tempxn XmlNode en nodePath)
388 {
389 XmlAttributeCollection xmlAttr = tempxn.Attributes;
390 para(int i=0; i<xmlAttr.Count; i++)
391 {
392 si (xmlAttr.Item(i).Name == NodeAttribute)
393 {
394 tempxn.Attributes.RemoveAt(i);
395 descanso;
396 }
397 }
398 }
399 }
400 }
401
402 /**//// <resumen>
403 /// Eliminar un nodo cuando el valor de su atributo es igual al valor dado
404 /// </summary>
405 /// <param name="NodePath">expresión xpath donde se encuentra el nodo</param>
406 /// <param name="NodeAttribute">Atributo</param>
407 /// <param nombre="NodeAttributeValue">valor</param>
408 public void DeleteAttribute (cadena NodePath, cadena NodeAttribute, cadena NodeAttributeValue)
409 {
410 XmlNodeList nodePath =this.xmlDoc.SelectNodes(NodePath);
411 si (!(nodePath==null))
412 {
413 foreach (tempxn XmlNode en nodePath)
414 {
415 XmlAttributeCollection xmlAttr = tempxn.Attributes;
416 para(int i=0; i<xmlAttr.Count; i++)
417 {
418 si (xmlAttr.Item(i).Name == NodeAttribute && xmlAttr.Item(i).Value==NodeAttributeValue)
419 {
420 tempxn.Atributos.RemoveAt(i);
421 descanso;
422 }
423 }
424 }
425 }
426 }
427 /**//// <resumen>
428 /// Eliminar nodo
429 /// </summary>
430 /// <param nombre="tempXmlNode"></param>
431 /// <comentarios></comentarios>
432 público vacío DeleteXmlNode (cadena tempXmlNode) {
433 XmlNodeList nodePath =this.xmlDoc.SelectNodes(tempXmlNode);
434 si (!(nodePath==null))
435 {
436 foreach(XmlNode xn en nodePath)
437 {
438 xn.ParentNode.RemoveChild(xn);
439 }
440 }
441 }
442
443 #regiónend
444
445 Evento de documento XML#región Evento de documento XML
446 /**//// <resumen>
447 ///
448 /// </summary>
449 /// <param nombre="src"></param>
450 /// <param nombre="args"></param>
451 nodo vacío privadoInsertEvent (Object src, argumentos XmlNodeChangedEventArgs)
452 {
453 //Guardar configuración
454 GuardarDocumentoXml();
455 }
456 /**//// <resumen>
457 ///
458 /// </summary>
459 /// <param nombre="src"></param>
460 /// <param nombre="args"></param>
461 nodo vacío privadoDeleteEvent (Object src, argumentos XmlNodeChangedEventArgs)
462 {
463 //Guardar configuración
464 GuardarDocumentoXml();
465 }
466 /**//// <resumen>
467 ///
468 /// </summary>
469 /// <param nombre="src"></param>
470 /// <param nombre="args"></param>
471 nodo vacío privadoUpdateEvent (Object src, argumentos XmlNodeChangedEventArgs)
472 {
473 //Guardar configuración
474 GuardarDocumentoXml();
475 }
476 #regiónend
477
478 Guardar archivo XML #región Guardar archivo XML
479 /**//// <resumen>
480 /// Función:
481 /// Guardar archivo XML
482 ///
483 /// </summary>
484 público vacío SaveXmlDocument()
485 {
486 intento
487 {
488 //Guardar los resultados de la configuración
489 si (this.xmlFilePathType == enumXmlPathType.AbsolutePath)
490 {
491 Guardarxml(xmlFilePath);
492 }
493 más si (this.xmlFilePathType == enumXmlPathType.VirtualPath)
494 {
495 Savexml(HttpContext.Current.Server.MapPath(xmlFilePath));
496 }
497 }
498 captura (XmlException xmle)
499 {
xml de 500 tiros;
501 }
502 }
503
504 /**//// <resumen>
505 /// Función:
506 /// Guardar archivo XML
507 /// </summary>
508 público vacío SaveXmlDocument (cadena tempXMLFilePath)
509 {
510 intento
511 {
512 //Guardar los resultados de la configuración
513 Guardarxml(tempXMLFilePath);
514 }
515 captura (XmlException xmle)
516 {
517 tiro xmle;
518 }
519 }
520 /**//// <resumen>
521 ///
522 /// </summary>
523 /// <param nombre="ruta de archivo"></param>
524 Savexml vacío privado (ruta de archivo de cadena)
525 {
526 xmlDoc.Save(ruta de archivo);
527 }
528
529 #endregion
530
531 }
532
533}
534
535