[转]c# 操作xml类 XmlDocument扩展类

于 2011-03-15 13:42:00 发布
阅读量144 收藏
点赞数
文章标签： c#
原文链接：http://www.cnblogs.com/hxworm/articles/1984802.html
版权

http://www.cnblogs.com/jiapengliang2005/articles/1671356.html

/*例如：
 *   XmlDocumentEX doc = new XmlDocumentEX();
        doc.CreateXmlFile("xmlDir\\myfile.xml", "<root>\r\n </root>");
        string xmlPath = SyFile.GetMapPath("xmlDir\\myfile.xml");
        doc.Load(xmlPath);

        //doc.InitializeNode("/root/com");

        XmlElement element = doc.CreateElement("name");

        doc.AppendChildElementByNameValue(ref element, "English", "likacompany");

        XmlNode node = doc.SelectSingleNode("/root");
        node.AppendChild(element);

        doc.Save(xmlPath); */

using System;
using System.IO;
using System.Data;
using System.Text;
using System.Xml;
using System.Text.RegularExpressions;

namespace SyLib
{
    /// <summary>
    /// c# 操作xml类  XmlDocument扩展类
    /// </summary>
    public class XmlDocumentEX:XmlDocument
    {        
        public XmlDocumentEX() : base()
        { }

        /// <summary>
        /// 加载的文件名(含路径)
        /// </summary>
        /// <param name="filename"></param>
        public override void Load(string filename)
        {           
            if (SyFile.FileExists(filename))
            {
                string path = SyFile.GetMapPath(filename);
                base.Load(path);
            }
            else
            {
                throw new Exception("文件: " + filename + " 不存在!");
            }
        }


        /// <summary>
        /// 在指定的Xml元素下,添加子Xml元素
        /// </summary>
        /// <param name="xmlElement">被追加子元素的Xml元素</param>
        /// <param name="childElementName">要添加的Xml元素名称</param>
        /// <param name="childElementValue">要添加的Xml元素值</param>
        /// <returns></returns>
        public bool AppendChildElementByNameValue(ref XmlElement xmlElement, string childElementName, object childElementValue)
        {
            return AppendChildElementByNameValue(ref xmlElement, childElementName, childElementValue, false);
        }


        /// <summary>
        /// 在指定的Xml元素下,添加子Xml元素
        /// </summary>
        /// <param name="xmlElement">被追加子元素的Xml元素</param>
        /// <param name="childElementName">要添加的Xml元素名称</param>
        /// <param name="childElementValue">要添加的Xml元素值</param>
        /// <param name="IsCDataSection">是否是CDataSection类型的子元素</param>
        /// <returns></returns>
        public bool AppendChildElementByNameValue(ref XmlElement xmlElement, string childElementName, object childElementValue, bool IsCDataSection)
        {
            if ((xmlElement != null) && (xmlElement.OwnerDocument != null))
            {
                //是否是CData类型Xml元素
                if (IsCDataSection)
                {
                    XmlCDataSection tempdata = xmlElement.OwnerDocument.CreateCDataSection(childElementName);
                    tempdata.InnerText = FiltrateControlCharacter(childElementValue.ToString());
                    XmlElement childXmlElement = xmlElement.OwnerDocument.CreateElement(childElementName);
                    childXmlElement.AppendChild(tempdata);
                    xmlElement.AppendChild(childXmlElement);
                }
                else
                {
                    XmlElement childXmlElement = xmlElement.OwnerDocument.CreateElement(childElementName);
                    childXmlElement.InnerText = FiltrateControlCharacter(childElementValue.ToString());
                    xmlElement.AppendChild(childXmlElement);
                }
                return true;
            }
            else
            {
                return false;
            }
        }

        /// <summary>
        /// 通过数据行向当前XML元素下追加子元素
        /// </summary>
        /// <param name="xmlElement">被追加子元素的Xml元素</param>
        /// <param name="dcc">当前数据表中的列集合</param>
        /// <param name="dr">当前行数据</param>
        /// <returns></returns>
        public bool AppendChildElementByDataRow(ref XmlElement xmlElement, DataColumnCollection dcc, DataRow dr)
        {
            return AppendChildElementByDataRow(ref xmlElement, dcc, dr, null);
        }

        /// <summary>
        /// 通过数据行向当前XML元素下追加子元素
        /// </summary>
        /// <param name="xmlElement">被追加子元素的Xml元素</param>
        /// <param name="dcc">当前数据表中的列集合</param>
        /// <param name="dr">当前行数据</param>
        /// <param name="removecols">不会被追加的列名</param>
        /// <returns></returns>
        public bool AppendChildElementByDataRow(ref XmlElement xmlElement, DataColumnCollection dcc, DataRow dr, string removecols)
        {
            if ((xmlElement != null) && (xmlElement.OwnerDocument != null))
            {
                foreach (DataColumn dc in dcc)
                {
                    if ((removecols == null) ||
                        (removecols == "") ||
                        (("," + removecols + ",").ToLower().IndexOf("," + dc.Caption.ToLower() + ",") < 0))
                    {
                        XmlElement tempElement = xmlElement.OwnerDocument.CreateElement(dc.Caption);
                        tempElement.InnerText = FiltrateControlCharacter(dr[dc.Caption].ToString().Trim());
                        xmlElement.AppendChild(tempElement);
                    }
                }
                return true;
            }
            else
            {
                return false;
            }
        }

        /// <summary>
        /// 实始化节点, 当节点存在则清除当前路径下的所有子结点, 如不存在则直接创建该结点
        /// </summary>
        /// <param name="xmlpath"></param>
        /// <returns></returns>
        public XmlNode InitializeNode(string xmlpath)
        {
            XmlNode xmlNode = this.SelectSingleNode(xmlpath);
            if (xmlNode != null)
            {
                xmlNode.RemoveAll();
            }
            else
            {
                xmlNode = CreateNode(xmlpath);
            }
            return xmlNode;
        }


        /// <summary>
        /// 删除指定路径下面的所有子结点和自身
        /// </summary>
        /// <param name="xmlpath">指定路径</param>
        public void RemoveNodeAndChildNode(string xmlpath)
        {
            XmlNodeList xmlNodeList = this.SelectNodes(xmlpath);
            if (xmlNodeList.Count > 0)
            {
                foreach (XmlNode xn in xmlNodeList)
                {
                    xn.RemoveAll();
                    xn.ParentNode.RemoveChild(xn);
                }
            }
        }

        /// <summary>
        /// 创建指定路径下的节点
        /// </summary>
        /// <param name="xmlpath">节点路径</param>
        /// <returns></returns>
        public XmlNode CreateNode(string xmlpath)
        {

            string[] xpathArray = xmlpath.Split('/');
            string root = "";
            XmlNode parentNode = this;
            //建立相关节点
            for (int i = 1; i < xpathArray.Length; i++)
            {
                XmlNode node = this.SelectSingleNode(root + "/" + xpathArray[i]);
                // 如果当前路径不存在则建立,否则设置当前路径到它的子路径上
                if (node == null)
                {
                    XmlElement newElement = this.CreateElement(xpathArray[i]);
                    parentNode.AppendChild(newElement);
                }
                //设置低一级的路径
                root = root + "/" + xpathArray[i];
                parentNode = this.SelectSingleNode(root);
            }

            return parentNode;
        }

        /// <summary>
        /// 得到指定路径的节点值
        /// </summary>
        /// <param name="xmlnode">要查找节点</param>
        /// <param name="path">指定路径</param>
        /// <returns></returns>
        public string GetSingleNodeValue(XmlNode xmlnode, string path)
        {
            if (xmlnode == null)
            {
                return null;
            }

            if (xmlnode.SelectSingleNode(path) != null)
            {
                if (xmlnode.SelectSingleNode(path).LastChild != null)
                {
                    return xmlnode.SelectSingleNode(path).LastChild.Value;
                }
                else
                {
                    return "";
                }
            }
            return null;
        }
        /// <summary>
        /// 得到指定节点名称的节点值
        /// eg:
        ///  XmlDocumentEX doc = new XmlDocumentEX();
        ///  doc.Load(SyFile.GetMapPath("App_Data\\syparam.xml"));
        ///  minPrice = doc.GetSingleNodeValue("/sys/bid", "minprice");        
        /// </summary>
        /// <param name="path">路径</param>
        /// <param name="nodeName">节点名称</param>
        /// <returns></returns>
        public string GetSingleNodeValue(string path, string nodeName)
        {
            XmlNodeList xnl = this.SelectSingleNode(path).ChildNodes;
            foreach (XmlNode xn in xnl)
            {
                if (xn.Name == nodeName)
                {
                    return xn.InnerText.ToString();                   
                }
            }
            return "";
        }

        /// <summary>
        /// 获取某节点的属性的值
        /// eg: string c = doc.GetAttributeValue("/root", "time", "value");
        /// </summary>
        /// <param name="path">此节点父路径</param>
        /// <param name="nodeName">节点名</param>
        /// <param name="attributeName">属性名</param>
        /// <returns>属性的值</returns>
        public string GetAttributeValue(string path, string nodeName, string attributeName)
        {
            XmlNodeList xnl = this.SelectSingleNode(path).ChildNodes;
            foreach (XmlNode xn in xnl)
            {
                if (xn.Name == nodeName)
                {
                    XmlElement xe = (XmlElement)xn;
                    return xe.GetAttribute(attributeName);
                }
            }
            return "";
        }
        /// <summary>
        /// 更新xml中的某个节点的innerText值
        /// eg：bool aa=  doc.UpdateByNode("/root","time", "我爱天安门");
        /// </summary>        
        /// <param name="path">本节点所在的父路径</param>
        /// <param name="nodeName">本节点的节点名称</param>
        /// <param name="innerText">节点内的文本值</param>
        /// <returns></returns>
        public bool UpdateByNode(string path, string nodeName,string innerText)
        {
            #region xml文件
            //<?xml version="1.0" encoding="utf-8"?>
            //<root>
            //  <func name="MP3播放" value="Prdt_ForMp3">
            //  </func>
            //  <func name="蓝牙" value="Prdt_BlueTooth">
            //  </func>
              
            //  <func name="日程表" value="Prdt_WorkPlan">
            //  </func>
            //  <time name="只显示2005年以后机型" value="2005"></time>
            //</root>
            #endregion
            XmlNodeList xnl = this.SelectSingleNode(path).ChildNodes;
            foreach (XmlNode xn in xnl)
            {
                if (xn.Name == nodeName)
                {
                    xn.InnerText = innerText;
                    return true;
                }                
            }
            return false;
        }
        /// <summary>
        /// 根据节点名和元素属性名 更新属性的值
        /// eg: bool aa = doc.UpdateAttributeByNode("/root","time", "value", "2008");
        /// </summary>
        /// <param name="path">节点父路径</param>
        /// /// <param name="attributeName">节点名字</param>
        /// <param name="attributeName">元素属性的名字</param>        
        /// <param name="newValue">属性更新后的值</param>
        /// <returns>true/false</returns>
        public bool UpdateAttributeByNode(string path,string nodeName, string attributeName, string newValue)
        {
            #region xml文件
            //<?xml version="1.0" encoding="utf-8"?>
            //<root>
            //  <func name="MP3播放" value="Prdt_ForMp3">
            //  </func>
            //  <func name="蓝牙" value="Prdt_BlueTooth">
            //  </func>

            //  <func name="日程表" value="Prdt_WorkPlan">
            //  </func>
            //  <time name="只显示2005年以后机型" value="2005"></time>
            //</root>
            #endregion
            XmlNodeList xnl = this.SelectSingleNode(path).ChildNodes;
            foreach (XmlNode xn in xnl)
            {
                if (xn.Name == nodeName)
                {
                    XmlElement xe = (XmlElement)xn;                    
                    xe.SetAttribute(attributeName, newValue);
                    return true;                    
                }
                
            }
            return false;
        }

        /// <summary>
        /// 过滤控制字符,包括0x00 - 0x08,0x0b - 0x0c,0x0e - 0x1f
        /// </summary>
        /// <param name="content">要过滤的内容</param>
        /// <returns>过滤后的内容</returns>
        private string FiltrateControlCharacter(string content)
        {
            return Regex.Replace(content, "[\x00-\x08|\x0b-\x0c|\x0e-\x1f]", "");
        }


        #region 向页面输出xml内容
        /// <summary>
        /// 向页面输出xml内容
        /// </summary>
        /// <param name="xmlnode">xml内容</param>
        public void ResponseXML(System.Text.StringBuilder xmlnode)
        {
            System.Web.HttpContext.Current.Response.Clear();
            System.Web.HttpContext.Current.Response.ContentType = "Text/XML";
            System.Web.HttpContext.Current.Response.Expires = 0;

            System.Web.HttpContext.Current.Response.Cache.SetNoStore();
            System.Web.HttpContext.Current.Response.Write(xmlnode.ToString());
            System.Web.HttpContext.Current.Response.End();
        }
        #endregion
        /// <summary>
        /// 创建一个xml文件
        /// </summary>
        /// <param name="filePath"></param>
        /// <param name="content"></param>
        /// <returns></returns>
        public bool CreateXmlFile(string filePath, string content)
        {
            bool returnValue = false;
            string header = "<?xml version=\"1.0\" encoding=\"utf-8\" ?> \r\n";
            string contents = header + content;

            filePath = SyFile.GetMapPath(filePath);
            if (filePath != null)
            {
                SyFile.WriteFile(filePath, contents, "utf-8");
                returnValue = true;
            }
            else
            {
                returnValue = false;
            }
            return returnValue;
        }
        /// <summary>
        /// 保存修改的xml文件
        /// </summary>
        /// <param name="path">文件路径 包含文件名</param>
        /// <returns></returns>
        public bool SaveXml(string path)
        {
            try
            {
                string tmpPath = SyFile.GetMapPath(path);
                base.Save(tmpPath);
                return true;
            }
            catch
            {
                return false;
            }

        }
    }
   
}

转载于:https://www.cnblogs.com/hxworm/articles/1984802.html

aptl84294
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值