Sempre quis escrever uma classe para operar arquivos XML. Pesquisei online hoje e encontrei uma classe semelhante que já havia escrito e modifiquei, e finalmente se tornou o seguinte código para referência de novatos.
//
Eventos XML são usados nesta classe. A busca por nós nesta classe deve usar expressões xpath. Se você não entende as expressões xpath, você pode verificar outro artigo em minha coleção: Operação de arquivo +XML: [Aprendendo xpath] XPath O. tutorial mais popular +
1usando Sistema;
2usando System.Xml;
3usando System.Web;
4namespacesolucky
5{
6 /**//// <resumo>
7 /// A expressão XPATH deve ser usada para obter o nó correspondente
8 /// Para informações sobre xpath, consulte:
9 /// </summary>
10 classe pública MyXml
11 {
12 Variável#região Variável
13 /**//// <resumo>
14 ///O tipo de caminho onde o arquivo xml está localizado
15 /// </summary>
16 /// <remarks>O tipo de caminho onde o arquivo xml está localizado</remarks>
17 enum público enumXmlPathType
18 {
19 /**//// <resumo>
20 /// Caminho absoluto
21 /// </summary>
22 Caminho Absoluto,
23 /**//// <resumo>
24 /// caminho virtual
25 /// </summary>
26Caminho Virtual
27}
28
29 string privada xmlFilePath;
30 privado enumXmlPathType xmlFilePathType;
31 XmlDocument privado xmlDoc = new XmlDocument();
32 #regiãofinal
33
34
35 propriedades#propriedades da região
36 /**//// <resumo>
37 /// Caminho do arquivo
38 /// </summary>
39 /// <remarks>Caminho do arquivo</remarks>
40 string pública XmlFilePath
41 {
42 obter
43 {
44 retorne este.xmlFilePath;
45}
46 conjuntos
47 {
48 xmlFilePath = valor;
49
50}
51}
52
53 /**//// <resumo>
54 /// Tipo de caminho do arquivo
55 /// </summary>
56 enumXmlPathType público XmlFilePathTyp
57 {
58 conjunto
59 {
60 xmlFilePathType = valor;
61}
62}
63 #regiãofinal
64
65 Construtor #region Construtor
66 /**//// <resumo>
67 ///
68 /// </summary>
69 /// <param name="tempXmlFilePath"></param>
70 MyXml público (string tempXmlFilePath)
71 {
72 //
73 // TODO: Adicione a lógica do construtor aqui
74 //
75
76 this.xmlFilePathType = enumXmlPathType.VirtualPath;
77 this.xmlFilePath = tempXmlFilePath;
78 GetXmlDocument();
79 //xmlDoc.Load(xmlFilePath);
80}
81
82 /**//// <resumo>
83 /// Construtor
84 /// </summary>
85 /// <param name="tempXmlFilePath">Caminho do arquivo</param>
86 /// <param name="tempXmlFilePathType">Tipo</param>
87 público MyXml(string tempXmlFilePath, enumXmlPathType tempXmlFilePathType)
88 {
89 //
90 // TODO: Adicione a lógica do construtor aqui
91 //
92 this.xmlFilePathType = tempXmlFilePathType;
93 this.xmlFilePath = tempXmlFilePath;
94 GetXmlDocument();
95}
96 #regiãofinal
97
98
99 /**////<resumo>
100 ///Obtém a classe de entidade XmlDocument
101 ///</summary>
102 /// <returns>Uma instância xmldocument do arquivo de descrição XML especificado</returns>
103 XmlDocument privado GetXmlDocument()
104 {
105 XmlDocument doc=null;
106
107 if( this.xmlFilePathType == enumXmlPathType.AbsolutePath )
108 {
109 doc = GetXmlDocumentFromFile(xmlFilePath);
110}
111 senão if( this.xmlFilePathType == enumXmlPathType.VirtualPath )
112 {
113 doc = GetXmlDocumentFromFile(HttpContext.Current.Server.MapPath(xmlFilePath));
114}
115 documento de retorno;
116}
117
118 XmlDocument privado GetXmlDocumentFromFile(string tempXmlFilePath)
119 {
120 string xmlFileFullPath = tempXmlFilePath;
121 xmlDoc.Load(xmlFileFullPath);
122 //Definir processamento de eventos
123 xmlDoc.NodeChanged += novo XmlNodeChangedEventHandler(this.nodeUpdateEvent);
124 xmlDoc.NodeInserted += novo XmlNodeChangedEventHandler(this.nodeInsertEvent);
125 xmlDoc.NodeRemoved += new XmlNodeChangedEventHandler(this.nodeDeleteEvent);
126 retorna xmlDoc;
127}
128
129 Leia o valor do atributo especificado do nó especificado #region Leia o valor do atributo especificado do nó especificado
130 /**//// <resumo>
131 /// Função:
132 /// Lê o valor do atributo especificado do nó especificado
133 /// </summary>
134 /// <param name="strNode">Nome do nó</param>
135 /// <param name="strAttribute">Atributos deste nó</param>
136 /// <retorna></retorna>
137 string pública GetXmlNodeAttributeValue(string strNode,string strAttribute)
138 {
139 string strReturn = "";
140 tentativas
141 {
142 //Obtém nós de acordo com o caminho especificado
143 XmlNode xmlNode = xmlDoc.SelectSingleNode(strNode);
144 se (!(xmlNode==nulo))
145 {//Obtenha os atributos do nó e execute o loop dos valores dos atributos necessários
146 XmlAttributeCollection xmlAttr = xmlNode.Attributes;
147
148 for(int i=0;i<xmlAttr.Count; i++)
149 {
150 if (xmlAttr.Item(i).Name == strAttribute)
151 {
152 strReturn = xmlAttr.Item(i).Value;
153 pausa;
154}
155}
156}
157}
158 captura(XmlException xmle)
159 {
160 lance xml;
161}
162 return strReturn;
163}
164 #regiãofinal
165
166
167 Leia o valor do nó especificado #region Leia o valor do nó especificado
168 /**//// <resumo>
169 /// Função:
170 /// Lê o valor do nó especificado
171 /// </summary>
172 /// <param name="strNode">Nome do nó</param>
173 /// <retorna></retorna>
174 string pública GetXmlNodeValue(string strNode)
175 {
176 string strReturn = String.Empty;
177
178 tentativa
179 {
180 //Obter nós com base no caminho
181 XmlNode xmlNode = xmlDoc.SelectSingleNode(strNode);
182 se (!(xmlNode==nulo))
183 strReturn = xmlNode.InnerText;
184}
185 captura(XmlException xmle)
186 {
187 lançar xml;
188}
189 return strReturn;
190}
191 #regiãofinal
192
193 Definir valor do nó #region Definir valor do nó
194 /**//// <resumo>
195 /// Função:
196 /// Definir valor do nó
197 /// </summary>
198 /// <param name="strNode">O nome do nó</param>
199 /// <param name="newValue">Valor do nó</param>
200 public void SetXmlNodeValue(string xmlNodePath,string xmlNodeValue)
201 {
202 tentativa
203 {
204 //Você pode pagar em lotes por nós que atendam às condições.
205 XmlNodeList xmlNode=this.xmlDoc.SelectNodes(xmlNodePath);
206 se (!(xmlNode==nulo))
207 {
208 foreach (XmlNode xn em xmlNode)
209 {
210 xn.InnerText = xmlNodeValue;
211}
212}
213 /**//*
214 * Obtenha nós de acordo com o caminho especificado
215 XmlNode xmlNode = xmlDoc.SelectSingleNode(xmlNodePath);
216 //Definir valor do nó
217 se (!(xmlNode==nulo))
218 xmlNode.InnerText = xmlNodeValue;*/
219}
220 captura(XmlException xmle)
221 {
222 lançar xml;
223}
224}
225 #regiãofinal
226
227 Defina o valor do atributo do nó #region Defina o valor do atributo do nó
228 /**//// <resumo>
229 /// Função:
230 ///Definir o valor do atributo do nó
231 /// </summary>
232 /// <param name="xmlNodePath">Nome do nó</param>
233 /// <param name="xmlNodeAttribute">Nome do atributo</param>
234 /// <param name="xmlNodeAttributeValue">Valor do atributo</param>
235 public void SetXmlNodeAttributeValue(string xmlNodePath,string xmlNodeAttribute,string xmlNodeAttributeValue)
236 {
237 tentar
238 {
239 //Você pode pagar atributos de nós qualificados em lotes
240 XmlNodeList xmlNode=this.xmlDoc.SelectNodes(xmlNodePath);
241 se (!(xmlNode==null))
242 {
243 foreach(XmlNode xn em xmlNode)
244 {
245 XmlAttributeCollection xmlAttr = xn.Attributes;
246 for(int i=0; i<xmlAttr.Count; i++)
247 {
248 if (xmlAttr.Item(i).Name == xmlNodeAttribute)
249 {
250 xmlAttr.Item(i).Value = xmlNodeAttributeValue;
251 pausa;
252}
253}
254}
255}
256 /**//*Nó único
257 //Obtém nós de acordo com o caminho especificado
258 XmlNode xmlNode = xmlDoc.SelectSingleNode(xmlNodePath);
259 se (!(xmlNode==nulo))
260 {//Obtenha os atributos do nó e execute o loop dos valores dos atributos necessários
261 XmlAttributeCollection xmlAttr = xmlNode.Attributes;
262 for(int i=0; i<xmlAttr.Count; i++)
263 {
264 if (xmlAttr.Item(i).Name == xmlNodeAttribute)
265 {
266 xmlAttr.Item(i).Value = xmlNodeAttributeValue;
267 pausa;
268}
269}
270}
271 */
272}
273 captura(XmlException xmle)
274 {
275 lançar xml;
276}
277}
278 #regiãofinal
279
280 Adicionar #região Adicionar
281 /**//// <resumo>
282 /// Obtém o elemento raiz do arquivo XML
283 /// </summary>
284 XmlNode público GetXmlRoot()
285 {
286 return xmlDoc.DocumentElement;
287}
288
289 /**//// <resumo>
290 /// Adiciona um nó pai sob o nó raiz
291 /// </summary>
292 public void AddParentNode(string parentNode)
293 {
294 tentativa
295 {
296 Raiz XmlNode = GetXmlRoot();
297 XmlNode parentXmlNode = xmlDoc.CreateElement(parentNode);
298 root.AppendChild(parentXmlNode);
299}
300 captura(XmlException xmle)
301 {
302 lançar xml;
303}
304}
305
306 /**//// <resumo>
307 /// Insere um nó filho em um nó pai existente
308 /// </summary>
309 /// <param name="parentNodePath">Nó pai</param>
310 /// <param name="childNodePath">nome do ponto de byte</param>
311 public void AddChildNode(string parentNodePath,string childnodename)
312 {
313 tentar
314 {
315 XmlNode parentXmlNode = xmlDoc.SelectSingleNode(parentNodePath);
316 if(!((parentXmlNode)==null))//Se este nó existir
317 {
318 XmlNode childXmlNode = xmlDoc.CreateElement(childnodename);
319 parentXmlNode.AppendChild(childXmlNode);
320}
321 else{//Se não existir, adicione o nó pai
322 //this.GetXmlRoot().AppendChild(childXmlNode);
323}
324
325}
326 captura(XmlException xmle)
327 {
328 lançar xml;
329}
330}
331
332 /**//// <resumo>
333 /// Adiciona atributos a um nó
334 /// </summary>
335 /// <param name="NodePath">Caminho do nó</param>
336 /// <param name="NodeAttribute">Nome do atributo</param>
337 public void AddAttribute(string NodePath, string NodeAttribute)
338 {
339 privateAddAttribute(NodePath,NodeAttribute,"");
340}
341 /**//// <resumo>
342 ///
343 /// </summary>
344 /// <param name="NodePath"></param>
345 /// <param name="NodeAttribute"></param>
346 /// <param name="NodeAttributeValue"></param>
347 privado void privateAddAttribute(string NodePath, string NodeAttribute,string NodeAttributeValue)
348 {
349 tentativa
350 {
351 XmlNode nodePath = xmlDoc.SelectSingleNode(NodePath);
352 se (!(nodePath==nulo))
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 lançar xml;
362}
363}
364 /**//// <resumo>
365 /// Adiciona atributos a um nó e paga valor
366 /// </summary>
367 /// <param name="NodePath">Nó</param>
368 /// <param name="NodeAttribute">Nome do atributo</param>
369 /// <param name="NodeAttributeValue">Valor do atributo</param>
370 public void AddAttribute(string NodePath, string NodeAttribute,string NodeAttributeValue)
371 {
372 privateAddAttribute(NodePath,NodeAttribute,NodeAttributeValue);
373}
374 #regiãofinal
375
376 Excluir #região Excluir
377 /**//// <resumo>
378 /// Exclui um atributo do nó
379 /// </summary>
380 /// <param name="NodePath">expressão xpath onde o nó está localizado</param>
381 /// <param name="NodeAttribute">Nome do atributo</param>
382 public void DeleteAttribute(string NodePath, string NodeAttribute)
383 {
384 XmlNodeList nodePath =this.xmlDoc.SelectNodes(NodePath);
385 se (!(nodePath==nulo))
386 {
387 foreach (XmlNode tempxn em nodePath)
388 {
389 XmlAttributeCollection xmlAttr = tempxn.Attributes;
390 for(int i=0; i<xmlAttr.Count; i++)
391 {
392 if (xmlAttr.Item(i).Name == NodeAttribute)
393 {
394 tempxn.Attributes.RemoveAt(i);
395 pausa;
396}
397}
398}
399}
400}
401
402 /**//// <resumo>
403 /// Exclui um nó quando seu valor de atributo é igual ao valor fornecido
404 /// </summary>
405 /// <param name="NodePath">expressão xpath onde o nó está localizado</param>
406 /// <param name="NodeAttribute">Atributo</param>
407 /// <param name="NodeAttributeValue">valor</param>
408 public void DeleteAttribute(string NodePath, string NodeAttribute, string NodeAttributeValue)
409 {
410 XmlNodeList nodePath =this.xmlDoc.SelectNodes(NodePath);
411 se (!(nodePath==nulo))
412 {
413 foreach (XmlNode tempxn em nodePath)
414 {
415 XmlAttributeCollection xmlAttr = tempxn.Attributes;
416 for(int i=0; i<xmlAttr.Count; i++)
417 {
418 if (xmlAttr.Item(i).Name == NodeAttribute && xmlAttr.Item(i).Value==NodeAttributeValue)
419 {
420 tempxn.Attributes.RemoveAt(i);
421 pausa;
422}
423}
424}
425}
426}
427 /**//// <resumo>
428 /// Excluir nó
429 /// </summary>
430 /// <param name="tempXmlNode"></param>
431 /// <observações></observações>
432 public void DeleteXmlNode(string tempXmlNode){
433 XmlNodeList nodePath =this.xmlDoc.SelectNodes(tempXmlNode);
434 se (!(nodePath==null))
435 {
436 foreach (XmlNode xn em nodePath)
437 {
438 xn.ParentNode.RemoveChild(xn);
439}
440}
441}
442
443 #regiãofinal
444
445 Evento de Documento XML#região Evento de Documento XML
446 /**//// <resumo>
447 ///
448 /// </summary>
449 /// <param name="src"></param>
450 /// <param name="args"></param>
451 privado void nodeInsertEvent (objeto src, XmlNodeChangedEventArgs args)
452 {
453 //Salvar configurações
454 SaveXmlDocument();
455}
456 /**//// <resumo>
457 ///
458 /// </summary>
459 /// <param name="src"></param>
460 /// <param name="args"></param>
461 privado void nodeDeleteEvent (objeto src, XmlNodeChangedEventArgs args)
462 {
463 //Salvar configurações
464 SaveXmlDocument();
465}
466 /**//// <resumo>
467 ///
468 /// </summary>
469 /// <param name="src"></param>
470 /// <param name="args"></param>
471 privado void nodeUpdateEvent (objeto src, XmlNodeChangedEventArgs args)
472 {
473 //Salvar configurações
474 SaveXmlDocument();
475}
476 #regiãofinal
477
478 Salvar arquivo XML #region Salvar arquivo XML
479 /**//// <resumo>
480 /// Função:
481 /// Salva arquivo XML
482 ///
483 /// </summary>
484 público vazio SaveXmlDocument()
485 {
486 tentativa
487 {
488 //Salva os resultados da configuração
489 if( this.xmlFilePathType == enumXmlPathType.AbsolutePath )
490 {
491 Salvarxml(xmlFilePath);
492}
493 senão if( this.xmlFilePathType == enumXmlPathType.VirtualPath )
494 {
495 Savexml(HttpContext.Current.Server.MapPath(xmlFilePath));
496}
497}
498 captura(XmlException xmle)
499 {
500 lances xml;
501}
502}
503
504 /**//// <resumo>
505 /// Função:
506 /// Salva arquivo XML
507 /// </summary>
508 public void SaveXmlDocument(string tempXMLFilePath)
509 {
510 tentativa
511 {
512 //Salva os resultados da configuração
513 Salvarxml(tempXMLFilePath);
514}
515 captura(XmlException xmle)
516 {
517 lançar xml;
518}
519}
520 /**//// <resumo>
521 ///
522 /// </summary>
523 /// <param name="filepath"></param>
524 private void Savexml(string caminho do arquivo)
525 {
526 xmlDoc.Save(caminho do arquivo);
527}
528
529 #regiãofinal
530
531}
532
533}
534
535