.net操纵xml文件类(c#)

1using System;
2using System.Xml;
3using System.Web;
4namespace solucky
5{
6    /**//// <summary>
7    /// 必需用XPATH表达式来获取相应节点
8    /// 关于xpath可以参见:
9    /// </summary>
10    public class MyXml
11    {
12        变量#region 变量
13        /**//// <summary>
14        /// xml文件所在路径类型
15        /// </summary>
16        /// <remarks>xml文件所在路径类型</remarks>
17        public enum enumXmlPathType
18        {
19            /**//// <summary>
20            /// 绝对路径
21            /// </summary>
22            AbsolutePath,
23            /**//// <summary>
24            /// 虚拟路径
25            /// </summary>
26            VirtualPath
27        }
28
29        private string xmlFilePath ;
30        private enumXmlPathType xmlFilePathType ;
31        private XmlDocument xmlDoc = new XmlDocument() ;
32        #endregion
33
34
35        属性#region 属性
36        /**//// <summary>
37        /// 文件路径
38        /// </summary>
39        /// <remarks>文件路径</remarks>
40        public string XmlFilePath
41        {
42            get
43            {
44                return this.xmlFilePath;
45            }
46            set
47            {
48                xmlFilePath = value ;
49
50            }
51        }
52
53        /**//// <summary>
54        /// 文件路径类型
55        /// </summary>
56        public enumXmlPathType XmlFilePathTyp
57        {
58            set
59            {
60                xmlFilePathType = value ;
61            }
62        }
63        #endregion
64
65        构造函数#region 构造函数
66        /**//// <summary>
67        ///
68        /// </summary>
69        /// <param name="tempXmlFilePath"></param>
70        public MyXml( string tempXmlFilePath )
71        {
72            //
73            // TODO: 在此处添加构造函数逻辑
74            //
75
76            this.xmlFilePathType = enumXmlPathType.VirtualPath ;
77            this.xmlFilePath = tempXmlFilePath ;
78            GetXmlDocument() ;
79            //xmlDoc.Load( xmlFilePath ) ;
80        }
81
82        /**//// <summary>
83        /// 构造函数
84        /// </summary>
85        /// <param name="tempXmlFilePath">文件路径</param>
86        /// <param name="tempXmlFilePathType">类型</param>
87        public MyXml( string tempXmlFilePath , enumXmlPathType tempXmlFilePathType )
88        {
89            //
90            // TODO: 在此处添加构造函数逻辑
91            //
92            this.xmlFilePathType = tempXmlFilePathType ;
93            this.xmlFilePath = tempXmlFilePath ;
94            GetXmlDocument() ;
95        }
96        #endregion
97
98
99        /**////<summary>
100        ///获取XmlDocument实体类
101        ///</summary>
102        /// <returns>指定的XML描述文件的一个xmldocument实例</returns>
103        private XmlDocument GetXmlDocument()
104        {
105            XmlDocument doc=null;
106
107            if( this.xmlFilePathType == enumXmlPathType.AbsolutePath )
108            {
109                doc = GetXmlDocumentFromFile( xmlFilePath ) ;
110            }
111            else if( this.xmlFilePathType == enumXmlPathType.VirtualPath )
112            {
113                doc = GetXmlDocumentFromFile(HttpContext.Current.Server.MapPath(xmlFilePath)) ;
114            }
115            return doc;
116        }
117
118        private XmlDocument GetXmlDocumentFromFile(string tempXmlFilePath)
119        {
120            string xmlFileFullPath = tempXmlFilePath ;
121            xmlDoc.Load(xmlFileFullPath) ;
122            //定义事件处理
123            xmlDoc.NodeChanged += new XmlNodeChangedEventHandler(this.nodeUpdateEvent);
124            xmlDoc.NodeInserted += new XmlNodeChangedEventHandler(this.nodeInsertEvent);
125            xmlDoc.NodeRemoved += new XmlNodeChangedEventHandler(this.nodeDeleteEvent);
126            return xmlDoc ;
127        }
128
129        读取指定节点的指定属性值#region 读取指定节点的指定属性值
130        /**//// <summary>
131        /// 功能:
132        /// 读取指定节点的指定属性值
133        /// </summary>
134        /// <param name="strNode">节点名称</param>
135        /// <param name="strAttribute">此节点的属性</param>
136        /// <returns></returns>
137        public string GetXmlNodeAttributeValue(string strNode,string strAttribute)
138        {
139            string strReturn = "";
140            try
141            {
142                //根据指定路径获取节点
143                XmlNode xmlNode = xmlDoc.SelectSingleNode(strNode) ;
144                if (!(xmlNode==null))
145                {//获取节点的属性，并循环取出需要的属性值
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                            break;
154                        }
155                    }
156                }
157            }
158            catch(XmlException xmle)
159            {
160                throw xmle ;
161            }
162            return strReturn ;
163        }
164        #endregion
165
166
167        读取指定节点的值#region 读取指定节点的值
168        /**//// <summary>
169        /// 功能:
170        /// 读取指定节点的值
171        /// </summary>
172        /// <param name="strNode">节点名称</param>
173        /// <returns></returns>
174        public string GetXmlNodeValue(string strNode)
175        {
176            string strReturn = String.Empty ;
177
178            try
179            {
180                //根据路径获取节点
181                XmlNode xmlNode = xmlDoc.SelectSingleNode(strNode) ;
182                if (!(xmlNode==null))
183                    strReturn = xmlNode.InnerText ;
184            }
185            catch(XmlException xmle)
186            {
187                throw xmle ;
188            }
189            return strReturn ;
190        }
191        #endregion
192
193        设置节点值#region 设置节点值
194        /**//// <summary>
195        /// 功能:
196        /// 设置节点值
197        /// </summary>
198        /// <param name="strNode">节点的名称</param>
199        /// <param name="newValue">节点值</param>
200        public void SetXmlNodeValue(string xmlNodePath,string xmlNodeValue)
201        {
202            try
203            {
204                //可以批量为符合条件的节点进行付值
205                XmlNodeList xmlNode=this.xmlDoc.SelectNodes(xmlNodePath);
206                if (!(xmlNode==null))
207                {
208                    foreach(XmlNode xn in xmlNode)
209                    {
210                        xn.InnerText = xmlNodeValue ;
211                    }
212                }
213                /**//*
214                 * 根据指定路径获取节点
215                XmlNode xmlNode = xmlDoc.SelectSingleNode(xmlNodePath) ;
216                //设置节点值
217                if (!(xmlNode==null))
218                    xmlNode.InnerText = xmlNodeValue ;*/
219            }
220            catch(XmlException xmle)
221            {
222                throw xmle ;
223            }
224        }
225        #endregion
226
227        设置节点的属性值#region 设置节点的属性值
228        /**//// <summary>
229        /// 功能:
230        /// 设置节点的属性值
231        /// </summary>
232        /// <param name="xmlNodePath">节点名称</param>
233        /// <param name="xmlNodeAttribute">属性名称</param>
234        /// <param name="xmlNodeAttributeValue">属性值</param>
235        public void SetXmlNodeAttributeValue(string xmlNodePath,string xmlNodeAttribute,string xmlNodeAttributeValue)
236        {
237            try
238            {
239                //可以批量为符合条件的节点的属性付值
240                XmlNodeList xmlNode=this.xmlDoc.SelectNodes(xmlNodePath);
241                if (!(xmlNode==null))
242                {
243                    foreach(XmlNode xn in 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                                break ;
252                            }
253                        }
254                    }
255                }
256                /**//*单个节点
257                //根据指定路径获取节点
258                XmlNode xmlNode = xmlDoc.SelectSingleNode(xmlNodePath) ;
259                if (!(xmlNode==null))
260                {//获取节点的属性，并循环取出需要的属性值
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                            break ;
268                        }
269                    }
270                }
271                */
272            }
273            catch(XmlException xmle)
274            {
275                throw xmle ;
276            }
277        }
278        #endregion
279
280        添加#region 添加
281        /**//// <summary>
282        /// 获取XML文件的根元素
283        /// </summary>
284        public XmlNode GetXmlRoot()
285        {
286            return xmlDoc.DocumentElement ;
287        }
288
289        /**//// <summary>
290        /// 在根节点下添加父节点
291        /// </summary>
292        public void AddParentNode(string parentNode)
293        {
294            try
295            {
296                XmlNode root = GetXmlRoot() ;
297                XmlNode parentXmlNode = xmlDoc.CreateElement(parentNode) ;
298                root.AppendChild(parentXmlNode) ;
299            }
300            catch(XmlException xmle)
301            {
302                throw xmle ;
303            }
304        }
305
306        /**//// <summary>
307        /// 向一个已经存在的父节点中插入一个子节点
308        /// </summary>
309        /// <param name="parentNodePath">父节点</param>
310        /// <param name="childNodePath">字节点名称</param>
311        public void AddChildNode( string parentNodePath,string childnodename )
312        {
313            try
314            {
315                XmlNode parentXmlNode = xmlDoc.SelectSingleNode(parentNodePath) ;
316                if(!((parentXmlNode)==null))//如果此节点存在
317                {
318                    XmlNode childXmlNode = xmlDoc.CreateElement(childnodename) ;
319                    parentXmlNode.AppendChild( childXmlNode ) ;
320                }
321                else{//如果不存在就放父节点添加
322                    //this.GetXmlRoot().AppendChild(childXmlNode);
323                }
324
325            }
326            catch(XmlException xmle)
327            {
328                throw xmle;
329            }
330        }
331
332        /**//// <summary>
333        /// 向一个节点添加属性
334        /// </summary>
335        /// <param name="NodePath">节点路径</param>
336        /// <param name="NodeAttribute">属性名</param>
337        public void AddAttribute( string NodePath , string NodeAttribute)
338        {
339            privateAddAttribute(NodePath,NodeAttribute,"");
340        }
341        /**//// <summary>
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            try
350            {
351                XmlNode nodePath = xmlDoc.SelectSingleNode( NodePath ) ;
352                if (!(nodePath==null))
353                {
354                    XmlAttribute nodeAttribute = this.xmlDoc.CreateAttribute(NodeAttribute);
355                    nodeAttribute.Value=NodeAttributeValue;
356                    nodePath.Attributes.Append(nodeAttribute) ;
357                }
358            }
359            catch(XmlException xmle)
360            {
361                throw xmle;
362            }
363        }
364        /**//// <summary>
365        /// 向一个节点添加属性,并付值
366        /// </summary>
367        /// <param name="NodePath">节点</param>
368        /// <param name="NodeAttribute">属性名</param>
369        /// <param name="NodeAttributeValue">属性值</param>
370        public void AddAttribute( string NodePath , string NodeAttribute,string NodeAttributeValue)
371        {
372            privateAddAttribute(NodePath,NodeAttribute,NodeAttributeValue);
373        }
374        #endregion
375
376        删除#region 删除
377        /**//// <summary>
378        /// 删除节点的一个属性
379        /// </summary>
380        /// <param name="NodePath">节点所在的xpath表达式</param>
381        /// <param name="NodeAttribute">属性名</param>
382        public void DeleteAttribute( string NodePath , string NodeAttribute)
383        {
384            XmlNodeList nodePath =this.xmlDoc.SelectNodes(NodePath);
385            if (!(nodePath==null))
386            {
387                foreach (XmlNode tempxn in 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                            break ;
396                        }
397                    }
398                }
399            }
400        }
401
402        /**//// <summary>
403        /// 删除节点,当其属性值等于给定的值时
404        /// </summary>
405        /// <param name="NodePath">节点所在的xpath表达式</param>
406        /// <param name="NodeAttribute">属性</param>
407        /// <param name="NodeAttributeValue">值</param>
408        public void DeleteAttribute( string NodePath , string NodeAttribute , string NodeAttributeValue)
409        {
410            XmlNodeList nodePath =this.xmlDoc.SelectNodes(NodePath);
411            if (!(nodePath==null))
412            {
413                foreach (XmlNode tempxn in 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                            break ;
422                        }
423                    }
424                }
425            }
426        }
427        /**//// <summary>
428        /// 删除节点
429        /// </summary>
430        /// <param name="tempXmlNode"></param>
431        /// <remarks></remarks>
432        public void DeleteXmlNode(string tempXmlNode){
433            XmlNodeList nodePath =this.xmlDoc.SelectNodes(tempXmlNode);
434            if (!(nodePath==null))
435            {
436                foreach(XmlNode xn in nodePath)
437                {
438                    xn.ParentNode.RemoveChild(xn);
439                }
440            }
441        }
442
443        #endregion
444
445        XML文档事件#region XML文档事件
446        /**//// <summary>
447        ///
448        /// </summary>
449        /// <param name="src"></param>
450        /// <param name="args"></param>
451        private void nodeInsertEvent(Object src, XmlNodeChangedEventArgs args)
452        {
453            //保存设置
454            SaveXmlDocument();
455        }
456        /**//// <summary>
457        ///
458        /// </summary>
459        /// <param name="src"></param>
460        /// <param name="args"></param>
461        private void nodeDeleteEvent(Object src, XmlNodeChangedEventArgs args)
462        {
463            //保存设置
464            SaveXmlDocument();
465        }
466        /**//// <summary>
467        ///
468        /// </summary>
469        /// <param name="src"></param>
470        /// <param name="args"></param>
471        private void nodeUpdateEvent(Object src, XmlNodeChangedEventArgs args)
472        {
473            //保存设置
474            SaveXmlDocument();
475        }
476        #endregion
477
478        保存XML文件#region 保存XML文件
479        /**//// <summary>
480        /// 功能:
481        /// 保存XML文件
482        ///
483        /// </summary>
484        public void SaveXmlDocument()
485        {
486            try
487            {
488                //保存设置的结果
489                if( this.xmlFilePathType == enumXmlPathType.AbsolutePath )
490                {
491                    Savexml( xmlFilePath ) ;
492                }
493                else if( this.xmlFilePathType == enumXmlPathType.VirtualPath )
494                {
495                    Savexml(HttpContext.Current.Server.MapPath(xmlFilePath)) ;
496                }
497            }
498            catch(XmlException xmle)
499            {
500                throw xmle;
501            }
502        }
503
504        /**//// <summary>
505        /// 功能:
506        /// 保存XML文件
507        /// </summary>
508        public void SaveXmlDocument(string tempXMLFilePath)
509        {
510            try
511            {
512                //保存设置的结果
513                Savexml(tempXMLFilePath);
514            }
515            catch(XmlException xmle)
516            {
517                throw xmle;
518            }
519        }
520        /**//// <summary>
521        ///
522        /// </summary>
523        /// <param name="filepath"></param>
524        private void Savexml(string filepath)
525        {
526            xmlDoc.Save(filepath);
527        }
528
529        #endregion
530
531    }
532
533}