一直想要写一个操作XML文件的类,今天在网上找了一下,找到一个已写的差不多的类,对其进行扩展与修改,最终成了以下代码,供新手参考参考.
　　//
　　在此类中用到了XML事件.此类中对于节点的查找必需用xpath表达式,如果你对xpath表达式不了解可以查看我收藏的另外一篇文章:+XML文件操作:[学习xpath]XPath最通俗的教程+

　　  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}
　　534
　　535