XM操作类

最新推荐文章于 2010-12-30 17:01:00 发布
最新推荐文章于 2010-12-30 17:01:00 发布
阅读量91 收藏
点赞数
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/Jebel/archive/2009/06/11/1501571.html
本文介绍了一个用于操作XML文件的实用类，该类提供了一系列方法，包括读取XML节点值、获取节点属性、添加和删除节点及属性等功能。

      新开发的学习平台中需要解析XML文件,读取XML节点的值.

 

ContractedBlock.gifExpandedBlockStart.gifCode
using System;
using System.Xml;
using System.Web;

namespace CommonLib.Utility
{
  
  /// <summary>
  /// XML核心类:
  /// 必需用XPath表达式来获取相应节点
  /// </summary>
  public class XmlCore
 {
     #region 变量-----------------------------------------------------------
 
     private string xmlFilePath;
     private XmlDocument xmlDoc = new XmlDocument();
     #endregion
 
     #region 属性-----------------------------------------------------------
     /// <summary>
     /// 文件路径
     /// </summary>
     /// <remarks>文件路径</remarks>
     public string XmlFilePath
     {
         get
         {
             return this.xmlFilePath;
         }
         set
         {
             xmlFilePath = value;
         }
     }
 
     #endregion
 
     #region 构造函数-------------------------------------------------------
     /// <summary>
     /// 构造函数
     /// </summary>
     /// <param name="tempXmlFilePath">已有的文件的路径</param>
     public XmlCore(string tempXmlFilePath)
     {
         this.xmlFilePath = tempXmlFilePath;
         GetXmlDocument();
     }
 
     /// <summary>
     /// 构造函数
     /// </summary>
     /// <param name="NewXmlFilePath">将要新建的文件路径</param>
     /// <param name="RootNodeName">根节点名称</param>
     public XmlCore(string NewXmlFilePath, string RootNodeName)
     {
         CreateNewXmlFile(NewXmlFilePath, RootNodeName);
         this.xmlFilePath = NewXmlFilePath;
         GetXmlDocument();
     }
 
     ///<summary>
     ///获取XmlDocument实体类
     ///</summary>   
     /// <returns>指定的XML描述文件的一个xmldocument实例</returns>
     private XmlDocument GetXmlDocument()
     {
         XmlDocument doc = null;
 
         doc = GetXmlDocumentFromFile(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;
     }
 
     private void CreateNewXmlFile(string filePath, string rootNode)
     {
         XmlTextWriter xtw = new XmlTextWriter(filePath, System.Text.Encoding.UTF8);
         xtw.Formatting = Formatting.Indented;
         xtw.WriteStartDocument(false);
         xtw.WriteStartElement(rootNode);
         xtw.WriteEndElement();
         xtw.Flush();
         xtw.Close();
     }
 
     #endregion
 
     #region 获取所有指定名称的节点
     /// <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

    #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

    #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

}


}

      以下是XML操作类代码：

       

 

转载于:https://www.cnblogs.com/Jebel/archive/2009/06/11/1501571.html

C#操纵XML的实例
03-18
关于C#操纵XML的一次小练习，跟大家分享一下。
xml文件操作类（对xml文件的创建、修改、保存、查询操作）
07-14
对xml文件的创建、修改、保存、查询操作
C#操作XML文件完整源码(十分经典)
03-01
C#操作XML文件完整源码(十分经典)
xml文件net操纵类(c#)
weixin_34146986的博客
01-26 297
    1using System;  2using System.Xml;  3using System.Web;  4namespace MX.XML  5{  6    /**//// &lt;summary&gt;  7    /// XML核心类:  8    /// 必需用XPath表达式来获取相应节点  9    /// &lt;/summary&gt; 10    public ...
XML操作类
aome1470的博客
03-24 156
public class XmlControl { protected string strXmlFile; protected XmlDocument objXmlDoc = new XmlDocument(); public XmlControl(string XmlFile) { // // TODO: 在这里加入建构函式的程序代码 // try { objXmlDoc.Lo...
C#实现的xml操作类完整实例
12-26
本文实例讲述了C#实现的xml操作类，分享给大家供大家参考，具体如下： using System; using System.Data; using System.Configuration; using System.Web; using System.Web.Security; using System.Web.UI; using ...
php实现的xml操作类
01-20
本文实例讲述了php实现的xml操作类。分享给大家供大家参考，具体如下： <?php /* 使用方法: $test=new xml(); $test->new_xml('test.xml'); $test->root('document'); $test->append_root_node('book'); $test->...
xm2vts_XM2VTS_python_
09-30
处理这类数据时，我们需要将其转换为 TensorFlow 可以理解的格式，例如numpy数组。 1. **数据预处理**：首先，你需要编写读取 PTS 文件的函数，将这些文件解析成合适的结构，如numpy数组。这可能涉及到读取文件，...
（亲测有效）喜马拉雅xm文件转mp3/m4a，支持批量转换格式、批量下载
最新发布
06-05
这类工具一般会提供用户友好的界面，允许用户导入多个XM文件，然后统一设定输出格式和质量参数。批量转换的优点在于可以节省大量手动操作的时间，尤其当需要处理大量文件时。 转换过程通常分为以下几步： 1. **...
C#实现的XML操作类实例与DataSet读取详解
本文档详细介绍了如何在C#中实现一个XML操作类（XmlHelper），该类作为一个基础工具，提供了对XML文件的高效处理功能。作者通过`System.Xml`命名空间利用C#的内置XML处理能力，展示了如何将XML数据读取到DataSet对象...
XML操作类（完整）
09-13
XML操作类（完整）使用于C#领域，更好的操作XML文件
C# XML操作类库（加强版）
09-27
最近做项目，要用C#写，而且数据格式是那种节点套节点能把人套死的XML，看着都觉得晕，而且节点跳跃性很大，真心觉得单纯用环境自带的XMLDocument类完全达不到自己的需要，因为XML里面涉及到节点循环，循环里面又套循环，说到这，我已经不想吐槽了，foreach是个好东西，但是套太多绝对是麻烦，不如封装成一个类库，自己想要的功能都加进去（较之前写的那个增加了节点，注释节点，带有属性节点的封装，以及附加了测试例子，功能很强大，也可以自己动手添加自己需要的方法），好了，0分分享！！！！！！；
C# XML操作类库
09-23
最近做项目，要用C#写，而且数据格式是那种节点套节点能把人套死的XML，看着都觉得晕，而且节点跳跃性很大，真心觉得单纯用环境自带的XMLDocument类完全达不到自己的需要，因为XML里面涉及到节点循环，循环里面又套循环，说到这，我已经不想吐槽了，foreach是个好东西，但是套太多绝对是麻烦，不如封装成一个类库，自己想要的功能都加进去，好了，0分分享；
XML操作类（转）
weixin_34179968的博客
03-24 278
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.WebControls.WebParts;using ...
Xml操作类
汤母嗑螺蛳
06-20 757
xml文件编程中经常用到，它的结构化存储数据可与数据库结合使用，也用于显示视图 。XmlHelper.csusing System;using System.Collections.Generic;using System.Text;using System.Xml;using System.Xml.Xsl;using System.Xml.Serialization;using Sy
xml操作类
weixin_30945039的博客
12-30 117
using System; using System.Data; using System.Web; using System.Xml; namespace HuLangCms { /// <summary> /// 类名:xml操作类 /// </summary> public class ExeCuteX...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值