实用的XML操作类

今天在搜硬盘的时候，无意间发现好久收藏还是整理的一个xml类，发现还蛮好蛮全的，正在用的朋友可以学习看看。收藏下，说不定时候你要用了但又想不起来的时候可以大大帮助你节省不少时间。

xml 操作类 下载 地址

http://www.dbcode.net/down/class/Xml操作类.rar

 如果你对xpath不是很知道，可以看看
http://www.w3school.com.cn/xpath/

C#操作xml之xpath语法

  以前也发过关于.net中操作XML的帖子，但不是很详细，现在我将详细介绍一下c#如何操作xml文件，正如学习操作数据库要学习SQL语言一样，在学 习操作xml与语言之前，我们要先熟悉一下xml的“sql”语句xpath。由于本系列帖子的目的不在于详细介绍xpath语法所以，我借用了园子里leves的帖子来简单介绍一下xpath语法：

XPath 是XML的查询语言，和SQL的角色很类似。以下面XML为例，介绍XPath 的语法。

<?xml version="1.0" encoding="ISO-8859-1"?>

<catalog>

 <cd country="USA">

    <title>Empire Burlesque</title>

    <artist>Bob Dylan</artist>

    <price>10.90</price>

 </cd>

 <cd country="UK">

    <title>Hide your heart</title>

    <artist>Bonnie Tyler</artist>

    <price>9.90</price>

 </cd>

 <cd country="USA">

    <title>Greatest Hits</title> 

    <artist>Dolly Parton</artist> 

    <price>9.90</price> 

  </cd>

</catalog>

定位节点
XML是树状结构，类似档案系统内数据夹的结构，XPath也类似档案系统的路径命名方式。不过XPath 是一种模式(Pattern)，可以选出 XML档案中，路径符合某个模式的所有节点出来。例如要选catalog底下的cd中所有price元素可以用：

/catalog/cd/price     

如果XPath的开头是一个斜线（/）代表这是绝对路径。如果开头是两个斜线（//）表示文件中所有符合模式的元素都会被选出来，即使是处于树中不同的层级也会被选出来。以下的语法会选出文件中所有叫做cd的元素（在树中的任何层级都会被选出来）：

//cd

选择未知的元素
使用星号（Wildcards,＊）可以选择未知的元素。下面这个语法会选出/catalog/cd 的所有子元素：

/catalog/cd/*

以下的语法会选出所有catalog的子元素中，包含有price作为子元素的元素。

/catalog/*/price

以下的语法会选出有两层父节点，叫做price的所有元素。

/*/*/price

以下的语法会选择出文件中的所有元素。

//*

要注意的是，想要存取不分层级的元素，XPath语法必须以两个斜线开头(//)，想要存取未知元素才用星号(*)，星号只能代表未知名称的元素，不能代表未知层级的元素。

选择分支
使用中括号可以选择分支。以下的语法从catalog的子元素中取出第一个叫做cd的元素。XPath的定义中没有第0元素这种东西。

/catalog/cd[1]

以下语法选择catalog中的最后一个cd元素：（XPathj并没有定义 first() 这种函式喔，用上例的 [1]就可以取出第一个元素。

/catalog/cd[last()]

以下语法选出含有price子元素的所有/catalog/cd元素。

/catalog/cd[price]

以下语法选出price元素的值等于10.90的所有/catalog/cd元素

/catalog/cd[price=10.90]

以下语法选出price元素的值等于10.90的所有/catalog/cd元素 的price元素

/catalog/cd[price=10.90]/price

选择一个以上的路径
使用Or操作数(|)就可以选择一个以上的路径。例如：

/catalog/cd/title | catalog/cd/artist

选择所有title以及artist元素

//title | //artist

选择所有title以及artist以及price元素

//title | //artist | //price

选择属性
在XPath中，除了选择元素以外，也可以选择属性。属性都是以@开头。例如选择文件中所有叫做country的属性：

//@country

选择所有含有country这个属性的cd元素：

//cd[@country]

以下语法选择出含有属性的所有cd元素

//cd[@*]

以下语法选择出country属性值为UK的cd元素

//cd[@country='UK']

 只要掌握了xpath语法，理论上你就可以访问xml文件中的任意节点和任意值

 using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;
using System.Xml;
/// <summary>
/// MyXml 的摘要说明
/// by twh
/// </summary>
public class MyXml
{/**//// <summary>
     /// 必需用XPATH表达式来获取相应节点
     /// 关于xpath可以参见:
     /// </summary>
         //变量#region 变量
         /**//// <summary>
         /// xml文件所在路径类型
         /// </summary>
         /// <remarks>xml文件所在路径类型</remarks>
         public enum enumXmlPathType
         {    
             /**//// <summary>
             /// 绝对路径
             /// </summary>
             AbsolutePath,
             /**//// <summary>
             /// 虚拟路径
             /// </summary>
             VirtualPath
         }
 
         private string xmlFilePath ;
         private enumXmlPathType xmlFilePathType ;
         private XmlDocument xmlDoc = new XmlDocument() ;
        
 
 
         //属性 属性
         /**//// <summary>
         /// 文件路径
         /// </summary>
         /// <remarks>文件路径</remarks>
         public string XmlFilePath
         {
             get
             {
                 return this.xmlFilePath;
             }
             set
             {
                 xmlFilePath = value ;
 
             }
         }
 
         /**//// <summary>
         /// 文件路径类型
         /// </summary>
         public enumXmlPathType XmlFilePathTyp
         {
             set
             {
                 xmlFilePathType = value ;
             }
         }
 
         //构造函数#region 构造函数
         /**//// <summary>
         ///
         /// </summary>
         /// <param name="tempXmlFilePath"></param>
         public MyXml( string tempXmlFilePath )
         {
             //
             // TODO: 在此处添加构造函数逻辑
             //
 
             this.xmlFilePathType = enumXmlPathType.VirtualPath ;
             this.xmlFilePath = tempXmlFilePath ;
             GetXmlDocument() ;
             //xmlDoc.Load( xmlFilePath ) ;
         }


    /**//// <summary>
       /// 构造函数
       /// </summary>
       /// <param name="tempXmlFilePath">文件路径</param>
       /// <param name="tempXmlFilePathType">类型</param>
       public MyXml( string tempXmlFilePath , enumXmlPathType tempXmlFilePathType )
       {
           //
           // TODO: 在此处添加构造函数逻辑
             //
             this.xmlFilePathType = tempXmlFilePathType ;
             this.xmlFilePath = tempXmlFilePath ;
             GetXmlDocument() ;
         }

        /**////<summary>
        ///获取XmlDocument实体类
        ///</summary>    
        /// <returns>指定的XML描述文件的一个xmldocument实例</returns>
        private XmlDocument GetXmlDocument()
        {
            XmlDocument doc=null;

            if( this.xmlFilePathType == enumXmlPathType.AbsolutePath )
            {
                doc = GetXmlDocumentFromFile( xmlFilePath ) ;
            }
            else if( this.xmlFilePathType == enumXmlPathType.VirtualPath )
            {
                doc = GetXmlDocumentFromFile(HttpContext.Current.Server.MapPath(xmlFilePath)) ;
            }
            return doc;
        }

        private XmlDocument GetXmlDocumentFromFile(string tempXmlFilePath)
        {
            string xmlFileFullPath = tempXmlFilePath ;
            xmlDoc.Load(xmlFileFullPath) ;
            //定义事件处理
            xmlDoc.NodeChanged += new XmlNodeChangedEventHandler(this.nodeUpdateEvent);
            xmlDoc.NodeInserted += new XmlNodeChangedEventHandler(this.nodeInsertEvent);
            xmlDoc.NodeRemoved += new XmlNodeChangedEventHandler(this.nodeDeleteEvent);
            return xmlDoc ;
        }

        //读取指定节点的指定属性值读取指定节点的指定属性值
        /**//// <summary>
        /// 功能:
        /// 读取指定节点的指定属性值    
        /// </summary>
        /// <param name="strNode">节点名称</param>
        /// <param name="strAttribute">此节点的属性</param>
        /// <returns></returns>
        public string GetXmlNodeAttributeValue(string strNode,string strAttribute)
        {
            string strReturn = "";
            try
            {
                //根据指定路径获取节点
                XmlNode xmlNode = xmlDoc.SelectSingleNode(strNode) ;
                if (!(xmlNode==null))
                {//获取节点的属性，并循环取出需要的属性值
                    XmlAttributeCollection xmlAttr = xmlNode.Attributes ;

                    for(int i=0 ;i<xmlAttr.Count; i++)
                    {
                        if (xmlAttr.Item(i).Name == strAttribute)
                        {
                            strReturn = xmlAttr.Item(i).Value ;
                            break;
                        }
                    }
                }
            }
            catch(XmlException xmle)
            {
                throw xmle ;
            }
            return strReturn ;
        }


        //读取指定节点的值 读取指定节点的值
        /**//// <summary>
        /// 功能:
        /// 读取指定节点的值    
        /// </summary>
        /// <param name="strNode">节点名称</param>
        /// <returns></returns>
        public string GetXmlNodeValue(string strNode)
        {
            string strReturn = String.Empty ;

            try
            {
                //根据路径获取节点
                XmlNode xmlNode = xmlDoc.SelectSingleNode(strNode) ;
                if (!(xmlNode==null))
                    strReturn = xmlNode.InnerText ;
            }
            catch(XmlException xmle)
            {
                throw xmle ;
            }
            return strReturn ;
        }


        //设置节点值设置节点值
        /**//// <summary>
        /// 功能:
        /// 设置节点值        
        /// </summary>
        /// <param name="strNode">节点的名称</param>
        /// <param name="newValue">节点值</param>
        public void SetXmlNodeValue(string xmlNodePath,string xmlNodeValue)
        {
            try
            {
                //可以批量为符合条件的节点进行付值
                XmlNodeList xmlNode=this.xmlDoc.SelectNodes(xmlNodePath);
                if (!(xmlNode==null))
                {
                    foreach(XmlNode xn in xmlNode)
                    {
                        xn.InnerText = xmlNodeValue ;    
                    }
                }
                /**//*
                 * 根据指定路径获取节点
                XmlNode xmlNode = xmlDoc.SelectSingleNode(xmlNodePath) ;            
                //设置节点值
                if (!(xmlNode==null))
                    xmlNode.InnerText = xmlNodeValue ;*/                
            }
            catch(XmlException xmle)
            {
                throw xmle ;
            }
        }
       

        ///设置节点的属性值 设置节点的属性值
        /**//// <summary>
        /// 功能:
        /// 设置节点的属性值    
        /// </summary>
        /// <param name="xmlNodePath">节点名称</param>
        /// <param name="xmlNodeAttribute">属性名称</param>
        /// <param name="xmlNodeAttributeValue">属性值</param>
        public void SetXmlNodeAttributeValue(string xmlNodePath,string xmlNodeAttribute,string xmlNodeAttributeValue)
        {
            try
            {
                //可以批量为符合条件的节点的属性付值
                XmlNodeList xmlNode=this.xmlDoc.SelectNodes(xmlNodePath);
                if (!(xmlNode==null))
                {
                    foreach(XmlNode xn in xmlNode)
                    {
                        XmlAttributeCollection xmlAttr = xn.Attributes ;
                        for(int i=0 ; i<xmlAttr.Count ; i++)
                        {
                            if ( xmlAttr.Item(i).Name == xmlNodeAttribute )
                            {
                                xmlAttr.Item(i).Value = xmlNodeAttributeValue;
                                break ;
                            }
                        }    
                    }
                }


                /**//*单个节点
                //根据指定路径获取节点
                XmlNode xmlNode = xmlDoc.SelectSingleNode(xmlNodePath) ;
                if (!(xmlNode==null))
                {//获取节点的属性，并循环取出需要的属性值
                    XmlAttributeCollection xmlAttr = xmlNode.Attributes ;
                    for(int i=0 ; i<xmlAttr.Count ; i++)
                    {
                        if ( xmlAttr.Item(i).Name == xmlNodeAttribute )
                        {
                            xmlAttr.Item(i).Value = xmlNodeAttributeValue;
                            break ;
                        }
                    }    
                }
                */
            }
            catch(XmlException xmle)
            {
                throw xmle ;
            }
        }
       

        //添加 添加
        /**//// <summary>
        /// 获取XML文件的根元素
        /// </summary>
        public XmlNode GetXmlRoot()
        {
            return xmlDoc.DocumentElement ;
        }

        /**//// <summary>
        /// 在根节点下添加父节点
        /// </summary>
        public void AddParentNode(string parentNode)
        {
            try
            {
                XmlNode root = GetXmlRoot() ;
                XmlNode parentXmlNode = xmlDoc.CreateElement(parentNode) ;
                root.AppendChild(parentXmlNode) ;                
            }
            catch(XmlException xmle)
            {
                throw xmle ;
            }
        }
        
        /**//// <summary>
        /// 向一个已经存在的父节点中插入一个子节点
        /// </summary>
        /// <param name="parentNodePath">父节点</param>
        /// <param name="childNodePath">字节点名称</param>
        public void AddChildNode( string parentNodePath,string childnodename )
        {
            try
            {
                XmlNode parentXmlNode = xmlDoc.SelectSingleNode(parentNodePath) ;                
                if(!((parentXmlNode)==null))//如果此节点存在
                {    
                    XmlNode childXmlNode =  xmlDoc.CreateElement(childnodename) ;                
                    parentXmlNode.AppendChild( childXmlNode ) ;    
                }
                else{//如果不存在就放父节点添加
                    //this.GetXmlRoot().AppendChild(childXmlNode);
                }
                            
            }
            catch(XmlException xmle)
            {
                throw xmle;
            }
        }
        
        /**//// <summary>
        /// 向一个节点添加属性
        /// </summary>
        /// <param name="NodePath">节点路径</param>
        /// <param name="NodeAttribute">属性名</param>
        public void AddAttribute( string NodePath , string NodeAttribute)
        {
            privateAddAttribute(NodePath,NodeAttribute,"");
        }
        /**//// <summary>
        ///
        /// </summary>
        /// <param name="NodePath"></param>
        /// <param name="NodeAttribute"></param>
        /// <param name="NodeAttributeValue"></param>
        private void privateAddAttribute( string NodePath , string NodeAttribute,string NodeAttributeValue)
        {
            try
            {
                XmlNode nodePath = xmlDoc.SelectSingleNode( NodePath ) ;
                if (!(nodePath==null))
                {    
                    XmlAttribute nodeAttribute = this.xmlDoc.CreateAttribute(NodeAttribute);
                    nodeAttribute.Value=NodeAttributeValue;
                    nodePath.Attributes.Append(nodeAttribute) ;                        
                }
            }
            catch(XmlException xmle)
            {
                throw xmle;
            }
        }
        /**//// <summary>
        ///  向一个节点添加属性,并付值
        /// </summary>
        /// <param name="NodePath">节点</param>
        /// <param name="NodeAttribute">属性名</param>
        /// <param name="NodeAttributeValue">属性值</param>
        public void AddAttribute( string NodePath , string NodeAttribute,string NodeAttributeValue)
        {
            privateAddAttribute(NodePath,NodeAttribute,NodeAttributeValue);
        }
       
    public string GetAllNodeValue(string NodePath)
    {
        System.Text.StringBuilder sb = new System.Text.StringBuilder();
        XmlNodeList nodePath= this.xmlDoc.SelectNodes(NodePath);
        if (!(nodePath==null))
        {
            foreach (XmlNode tempxn in nodePath)
            {
                sb.Append(tempxn.InnerText+",");
            }
        }
        return sb.ToString();
    }

        //删除 删除
        /**//// <summary>
        /// 删除节点的一个属性
        /// </summary>
        /// <param name="NodePath">节点所在的xpath表达式</param>
        /// <param name="NodeAttribute">属性名</param>
        public void DeleteAttribute( string NodePath , string NodeAttribute)
        {            
            XmlNodeList nodePath =this.xmlDoc.SelectNodes(NodePath);            
            if (!(nodePath==null))
            {
                foreach (XmlNode tempxn in nodePath)
                {
                    XmlAttributeCollection xmlAttr = tempxn.Attributes ;
                    for(int i=0 ; i<xmlAttr.Count ; i++)
                    {
                        if ( xmlAttr.Item(i).Name == NodeAttribute)
                        {
                            tempxn.Attributes.RemoveAt(i);
                            break ;
                        }
                    }
                }
            }
        }

      
        /**//// <summary>
        /// 删除节点,当其属性值等于给定的值时
        /// </summary>
        /// <param name="NodePath">节点所在的xpath表达式</param>
        /// <param name="NodeAttribute">属性</param>
        /// <param name="NodeAttributeValue">值</param>
        public void DeleteAttribute( string NodePath , string NodeAttribute , string NodeAttributeValue)
        {
            XmlNodeList nodePath =this.xmlDoc.SelectNodes(NodePath);            
            if (!(nodePath==null))
            {
                foreach (XmlNode tempxn in nodePath)
                {
                    XmlAttributeCollection xmlAttr = tempxn.Attributes ;
                    for(int i=0 ; i<xmlAttr.Count ; i++)
                    {
                        if ( xmlAttr.Item(i).Name == NodeAttribute && xmlAttr.Item(i).Value==NodeAttributeValue)
                        {
                            tempxn.Attributes.RemoveAt(i);
                            break ;
                        }
                    }
                }
            }
        }
        /**//// <summary>
        /// 删除节点
        /// </summary>
        /// <param name="tempXmlNode"></param>
        /// <remarks></remarks>
        public void DeleteXmlNode(string tempXmlNode){    
            XmlNodeList nodePath =this.xmlDoc.SelectNodes(tempXmlNode);
            if (!(nodePath==null))
            {
                foreach(XmlNode xn in nodePath)
                {
                    xn.ParentNode.RemoveChild(xn);        
                }
            }
        }

       

        //XML文档事件 XML文档事件
        /**//// <summary>
        ///
        /// </summary>
        /// <param name="src"></param>
        /// <param name="args"></param>
        private  void nodeInsertEvent(Object src, XmlNodeChangedEventArgs args)
        {
            //保存设置
            SaveXmlDocument();
        }
        /**//// <summary>
        ///
        /// </summary>
        /// <param name="src"></param>
        /// <param name="args"></param>
        private  void nodeDeleteEvent(Object src, XmlNodeChangedEventArgs args)
        {
            //保存设置
            SaveXmlDocument();
        }
        /**//// <summary>
        ///
        /// </summary>
        /// <param name="src"></param>
        /// <param name="args"></param>
        private  void nodeUpdateEvent(Object src, XmlNodeChangedEventArgs args)
        {
            //保存设置
            SaveXmlDocument();
        }
       

       // 保存XML文件 保存XML文件
        /**//// <summary>
        /// 功能:
        /// 保存XML文件
        ///
        /// </summary>
        public void SaveXmlDocument()
        {
            try
            {
                //保存设置的结果
                if( this.xmlFilePathType == enumXmlPathType.AbsolutePath )
                {
                    Savexml( xmlFilePath ) ;
                }
                else if( this.xmlFilePathType == enumXmlPathType.VirtualPath )
                {
                    Savexml(HttpContext.Current.Server.MapPath(xmlFilePath)) ;
                }
            }
            catch(XmlException xmle)
            {
                throw xmle;
            }
        }
    
        /**//// <summary>
        /// 功能:
        /// 保存XML文件    
        /// </summary>
        public void SaveXmlDocument(string tempXMLFilePath)
        {
            try
            {
                //保存设置的结果
                Savexml(tempXMLFilePath);
            }
            catch(XmlException xmle)
            {
                throw xmle;
            }
        }
        /**//// <summary>
        ///
        /// </summary>
        /// <param name="filepath"></param>
        private void Savexml(string filepath)
        {
            xmlDoc.Save(filepath);
        }
}