xml 文件操作类

  1using System;
  2using System.Xml;
  3using System.Web;
  4
  5/**//// <summary>
  6/// XML核心类:
  7/// 必需用XPath表达式来获取相应节点
  8/// </summary>
  9public class XmlCore
 10{
 11    变量-----------------------------------------------------------#region 变量-----------------------------------------------------------
 12
 13
 14    private string xmlFilePath;
 15    private XmlDocument xmlDoc = new XmlDocument();
 16    #endregion
 17
 18    属性-----------------------------------------------------------#region 属性-----------------------------------------------------------
 19    /**//// <summary>
 20    /// 文件路径
 21    /// </summary>
 22    /// <remarks>文件路径</remarks>
 23    public string XmlFilePath
 24    {
 25        get
 26        {
 27            return this.xmlFilePath;
 28        }
 29        set
 30        {
 31            xmlFilePath = value;
 32
 33        }
 34    }
 35
 36    #endregion
 37
 38    构造函数-------------------------------------------------------#region 构造函数-------------------------------------------------------
 39    /**//// <summary>
 40    /// 构造函数
 41    /// </summary>
 42    /// <param name="tempXmlFilePath">已有的文件的路径</param>
 43    public XmlCore(string tempXmlFilePath)
 44    {
 45        this.xmlFilePath = tempXmlFilePath;
 46        GetXmlDocument();
 47    }
 48
 49    /**//// <summary>
 50    /// 构造函数
 51    /// </summary>
 52    /// <param name="NewXmlFilePath">将要新建的文件路径</param>
 53    /// <param name="RootNodeName">根节点名称</param>
 54    public XmlCore(string NewXmlFilePath, string RootNodeName)
 55    {
 56        CreateNewXmlFile(NewXmlFilePath, RootNodeName);
 57        this.xmlFilePath = NewXmlFilePath;
 58        GetXmlDocument();
 59    }
 60
 61    /**////<summary>
 62    ///获取XmlDocument实体类
 63    ///</summary>   
 64    /// <returns>指定的XML描述文件的一个xmldocument实例</returns>
 65    private XmlDocument GetXmlDocument()
 66    {
 67        XmlDocument doc = null;
 68
 69        doc = GetXmlDocumentFromFile(xmlFilePath);
 70
 71        return doc;
 72    }
 73
 74    private XmlDocument GetXmlDocumentFromFile(string tempXmlFilePath)
 75    {
 76        string xmlFileFullPath = tempXmlFilePath;
 77        xmlDoc.Load(xmlFileFullPath);
 78        //定义事件处理
 79        xmlDoc.NodeChanged += new XmlNodeChangedEventHandler(this.nodeUpdateEvent);
 80        xmlDoc.NodeInserted += new XmlNodeChangedEventHandler(this.nodeInsertEvent);
 81        xmlDoc.NodeRemoved += new XmlNodeChangedEventHandler(this.nodeDeleteEvent);
 82        return xmlDoc;
 83    }
 84
 85    private void CreateNewXmlFile(string filePath, string rootNode)
 86    {
 87        XmlTextWriter xtw = new XmlTextWriter(filePath, System.Text.Encoding.UTF8);
 88        xtw.Formatting = Formatting.Indented;
 89        xtw.WriteStartDocument(false);
 90        xtw.WriteStartElement(rootNode);
 91        xtw.WriteEndElement();
 92        xtw.Flush();
 93        xtw.Close();
 94    }
 95
 96    #endregion
 97
 98    获取所有指定名称的节点#region 获取所有指定名称的节点
 99    /**//// <summary>
    /// 功能:
    /// 获取所有指定名称的节点(XmlNodeList)
    /// </summary>
    /// <param >节点名称</param>
    public XmlNodeList GetXmlNodeList(string strNode)
    {
        XmlNodeList strReturn = null;
        try
        {
            //根据指定路径获取节点
            XmlNodeList xmlNode = xmlDoc.SelectNodes(strNode);
            if (!(xmlNode == null))
            {
                strReturn = xmlNode;
            }
        }
        catch (XmlException xmle)
        {
            throw xmle;
        }
        return strReturn;
    }
    #endregion

    读取指定节点的指定属性值---------------------------------------#region 读取指定节点的指定属性值---------------------------------------
    /**//// <summary>
    /// 功能:
    /// 读取指定节点的指定属性值(Value)
    /// </summary>
    /// <param >节点名称</param>
    /// <param >此节点的属性</param>
    /// <returns></returns>
    public string GetXmlNodeAttributeValue(string strNode, string strAttribute)
    {
        string strReturn = "";
        try
        {
            //根据指定路径获取节点
            XmlNode xmlNode = xmlDoc.SelectSingleNode(strNode);
            if (!(xmlNode == null))
            {
                strReturn = xmlNode.Attributes.GetNamedItem(strAttribute).Value;

                /**/////获取节点的属性，并循环取出需要的属性值
                //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;
    }
    #endregion

    读取指定节点的值-----------------------------------------------#region 读取指定节点的值-----------------------------------------------
    /**//// <summary>
    /// 功能:
    /// 读取指定节点的值(InnerText)
    /// </summary>
    /// <param >节点名称</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;
    }
    #endregion

    设置节点值-----------------------------------------------------#region 设置节点值-----------------------------------------------------
    /**//// <summary>
    /// 功能:
    /// 设置节点值(InnerText)
    /// </summary>
    /// <param >节点的名称</param>
    /// <param >节点值</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;
        }
    }
    #endregion

    设置节点的属性值-----------------------------------------------#region 设置节点的属性值-----------------------------------------------
    /**//// <summary>
    /// 功能:
    /// 设置节点的属性值   
    /// </summary>
    /// <param >节点名称</param>
    /// <param >属性名称</param>
    /// <param >属性值</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;
                        }
                    }
                }
            }
        }
        catch (XmlException xmle)
        {
            throw xmle;
        }
    }
    #endregion

    添加-----------------------------------------------------------#region 添加-----------------------------------------------------------
    /**//// <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 >父节点</param>
    /// <param >字节点名称</param>
    public XmlNode AddChildNode(string parentNodePath, string childnodename)
    {
        XmlNode childXmlNode = null;
        try
        {
            XmlNode parentXmlNode = xmlDoc.SelectSingleNode(parentNodePath);
            if (!((parentXmlNode) == null))//如果此节点存在
            {
                childXmlNode = xmlDoc.CreateElement(childnodename);
                parentXmlNode.AppendChild(childXmlNode);
            }
            else
            {//如果不存在就放父节点添加
                this.GetXmlRoot().AppendChild(childXmlNode);
            }
        }
        catch (XmlException xmle)
        {
            throw xmle;
        }
        return childXmlNode;
    }
    /**//// <summary>
    /// 向一个已经存在的父节点中插入一个子节点,并添加一个属性
    /// </summary>
    public void AddChildNode(string parentNodePath, string childnodename, string NodeAttribute, string NodeAttributeValue)
    {
        try
        {
            XmlNode parentXmlNode = xmlDoc.SelectSingleNode(parentNodePath);
            XmlNode childXmlNode = null;
            if (!((parentXmlNode) == null))//如果此节点存在
            {
                childXmlNode = xmlDoc.CreateElement(childnodename);

                //添加属性
                XmlAttribute nodeAttribute = this.xmlDoc.CreateAttribute(NodeAttribute);
                nodeAttribute.Value = NodeAttributeValue;
                childXmlNode.Attributes.Append(nodeAttribute);

                parentXmlNode.AppendChild(childXmlNode);
            }
            else
            {//如果不存在就放父节点添加
                this.GetXmlRoot().AppendChild(childXmlNode);
            }
        }
        catch (XmlException xmle)
        {
            throw xmle;
        }
    }

    /**//// <summary>
    /// 向一个节点添加属性,值为空
    /// </summary>
    /// <param >节点路径</param>
    /// <param >属性名</param>
    public void AddAttribute(string NodePath, string NodeAttribute)
    {
        privateAddAttribute(NodePath, NodeAttribute, "");
    }
    /**//// <summary>
    /// 向一个节点添加属性,并赋值***
    /// </summary>
    public void AddAttribute(XmlNode childXmlNode, string NodeAttribute, string NodeAttributeValue)
    {
        XmlAttribute nodeAttribute = this.xmlDoc.CreateAttribute(NodeAttribute);
        nodeAttribute.Value = NodeAttributeValue;
        childXmlNode.Attributes.Append(nodeAttribute);
    }

    /**//// <summary>
    /// 向一个节点添加属性
    /// </summary>
    /// <param >节点路径</param>
    /// <param >属性名</param>
    /// <param >属性值</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 >节点</param>
    /// <param >属性名</param>
    /// <param >属性值</param>
    public void AddAttribute(string NodePath, string NodeAttribute, string NodeAttributeValue)
    {
        privateAddAttribute(NodePath, NodeAttribute, NodeAttributeValue);
    }
    #endregion

    删除-----------------------------------------------------------#region 删除-----------------------------------------------------------
    /**//// <summary>
    /// 删除节点的一个属性
    /// </summary>
    /// <param >节点所在的xpath表达式</param>
    /// <param >属性名</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 >节点所在的xpath表达式</param>
    /// <param >属性</param>
    /// <param >值</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 ></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);
            }
        }
    }

    #endregion

    XML文档事件----------------------------------------------------#region XML文档事件----------------------------------------------------
    /**//// <summary>
    /// 节点插入事件
    /// </summary>
    /// <param ></param>
    /// <param ></param>
    private void nodeInsertEvent(Object src, XmlNodeChangedEventArgs args)
    {
        //保存设置
        SaveXmlDocument();
    }
    /**//// <summary>
    /// 节点删除事件
    /// </summary>
    /// <param ></param>
    /// <param ></param>
    private void nodeDeleteEvent(Object src, XmlNodeChangedEventArgs args)
    {
        //保存设置
        SaveXmlDocument();
    }
    /**//// <summary>
    /// 节点更新事件
    /// </summary>
    /// <param ></param>
    /// <param ></param>
    private void nodeUpdateEvent(Object src, XmlNodeChangedEventArgs args)
    {
        //保存设置
        SaveXmlDocument();
    }
    #endregion

    保存XML文件----------------------------------------------------#region 保存XML文件----------------------------------------------------
    /**//// <summary>
    /// 功能:
    /// 保存XML文件
    /// </summary>
    public void SaveXmlDocument()
    {
        try
        {
            //保存设置的结果
            Savexml(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 ></param>
    private void Savexml(string filepath)
    {
        xmlDoc.Save(filepath);
    }

    #endregion

}