现在的位置: 首页 > 综合 > 正文

XMLHelper

2013年07月13日 ⁄ 综合 ⁄ 共 8528字 ⁄ 字号 小 中 大 ⁄ 评论关闭
全部源码下载地址：http://download.csdn.net/source/855790

  1. using System;
  2. using System.Data;
  3. using System.Configuration;
  4. using System.Web;
  5. using System.Web.Security;
  6. using System.Web.UI;
  7. using System.Web.UI.WebControls;
  8. using System.Web.UI.WebControls.WebParts;
  9. using System.Web.UI.HtmlControls;
  10. using System.Collections;
  12. //引用命名空间
  13. using System.Xml;
  16. namespace xmlOp
  17. {
  18. /// <summary>
  19. /// XmlOp类提供对XML数据库的读写
  20. /// </summary>
  21.     public class XmlOp
  22.     {
  23.         //声明一个XmlDocument空对象
  24.         protected XmlDocument XmlDoc = new XmlDocument();
  26.         /// <summary>
  27.         /// 构造函数，导入Xml文件
  28.         /// </summary>
  29.         /// <param name="xmlFile">文件虚拟路径</param>
  30.         public XmlOp(string xmlFile)
  31.         {
  32.             try
  33.             {
  34.                 XmlDoc.Load(GetXmlFilePath(xmlFile));   //载入Xml文档
  35.             }
  36.             catch (System.Exception ex)
  37.             {
  38.                 throw ex;
  39.             }
  40.         }
  41.         /// <summary>
  42.         /// 析构函数
  43.         /// </summary>
  44.         ~XmlOp()
  45.         {
  46.             XmlDoc = null;  //释放XmlDocument对象
  47.         }
  49.         /// <summary>
  50.         /// 保存文件
  51.         /// </summary>
  52.         /// <param name="filePath">文件虚拟路径</param>
  53.         public void Save(string filePath)
  54.         {
  55.             try
  56.             {
  57.                 XmlDoc.Save(GetXmlFilePath(filePath));
  58.             }
  59.             catch (System.Exception ex)
  60.             {
  61.                 throw ex;
  62.             }
  63.         }
  65.         /// <summary>
  66.         /// 返回Xml文件实际路径
  67.         /// </summary>
  68.         /// <param name="xmlFile">文件虚拟路径</param>
  69.         /// <returns></returns>
  70.         public string GetXmlFilePath(string xmlFile)
  71.         {
  72.             return HttpContext.Current.Server.MapPath(xmlFile);
  73.         }
  75.         /// <summary>
  76.         /// 根据Xml文件的节点路径，返回一个DataSet数据集
  77.         /// </summary>
  78.         /// <param name="XmlPathNode">Xml文件的某个节点</param>
  79.         /// <returns></returns>
  80.         public DataSet GetDs(string XmlPathNode)
  81.         {
  82.             DataSet ds = new DataSet();
  83.             try
  84.             {                
  85.                 System.IO.StringReader read = new System.IO.StringReader(XmlDoc.SelectSingleNode(XmlPathNode).OuterXml);
  86.                 ds.ReadXml(read);   //利用DataSet的ReadXml方法读取StringReader文件流
  87.                 read.Close();
  88.             }
  89.             catch
  90.             { }
  91.             return ds;
  92.         }
  94.         /// <summary>
  95.         /// 属性查询，返回属性值
  96.         /// </summary>
  97.         /// <param name="XmlPathNode">属性所在的节点</param>
  98.         /// <param name="Attrib">属性</param>
  99.         /// <returns></returns>
  100.         public string SelectAttrib(string XmlPathNode, string Attrib)
  101.         {
  102.             string _strNode="";
  103.             try
  104.             {
  105.                 _strNode = XmlDoc.SelectSingleNode(XmlPathNode).Attributes[Attrib].Value;
  106.             }
  107.             catch
  108.             { }
  109.             return _strNode;
  110.         }
  112.         /// <summary>
  113.         /// 节点查询，返回节点值
  114.         /// </summary>
  115.         /// <param name="XmlPathNode">节点的路径</param>
  116.         /// <returns></returns>
  117.         public string SelectNodeText(string XmlPathNode)
  118.         {
  119.             string _nodeTxt = XmlDoc.SelectSingleNode(XmlPathNode).InnerText;
  120.             if (_nodeTxt == null || _nodeTxt == "")
  121.                 return "";
  122.             else
  123.                 return _nodeTxt;
  124.         }
  126.         /// <summary>
  127.         /// 节点值查询判断
  128.         /// </summary>
  129.         /// <param name="XmlPathNode">父节点</param>
  130.         /// <param name="index">节点索引</param>
  131.         /// <param name="NodeText">节点值</param>
  132.         /// <returns></returns>
  133.         public bool SelectNode(string XmlPathNode, int index, string NodeText)
  134.         {
  135.             try
  136.             {
  137.                 XmlNodeList _NodeList = XmlDoc.SelectNodes(XmlPathNode);
  138.                 //循环遍历节点，查询是否存在该节点
  139.                 for (int i = 0; i < _NodeList.Count; i++)
  140.                 {
  141.                     if (_NodeList[i].ChildNodes[index].InnerText == NodeText)
  142.                     {
  143.                         return true;
  144.                         break;
  145.                     }
  146.                 }
  147.             }
  148.             catch
  149.             {                
  150.             }
  151.             return false;
  152.         }
  154.         /// <summary>
  155.         /// 获取子节点个数
  156.         /// </summary>
  157.         /// <param name="XmlPathNode">父节点</param>
  158.         /// <returns></returns>
  159.         public int NodeCount(string XmlPathNode)
  160.         {
  161.             int i = 0;
  162.             try
  163.             {
  164.                 i=XmlDoc.SelectSingleNode(XmlPathNode).ChildNodes.Count;                
  165.             }
  166.             catch
  167.             {
  168.                 i=0;
  169.             }
  170.             return i;
  171.         }
  173.         /// <summary>
  174.         /// 更新一个节点的内容
  175.         /// </summary>
  176.         /// <param name="XmlPathNode">节点的路径</param>
  177.         /// <param name="Content">新的节点值</param>
  178.         /// <returns></returns>
  179.         public bool UpdateNode(string XmlPathNode,string NodeContent)
  180.         {
  181.             try
  182.             {
  183.                 XmlDoc.SelectSingleNode(XmlPathNode).InnerText = NodeContent;
  184.                 return true;
  185.             }
  186.             catch
  187.             {
  188.                 return false;
  189.             }
  190.         }
  192.         /// <summary>
  193.         /// 更新N个节点值
  194.         /// </summary>
  195.         /// <param name="XmlParentNode">父节点</param>
  196.         /// <param name="XmlNode">子节点</param>
  197.         /// <param name="NodeContent">子节点内容</param>
  198.         /// <returns></returns>
  199.         public bool UpdateNode(string XmlParentNode, string[] XmlNode, string[] NodeContent)
  200.         {               
  201.             try
  202.             {
  203.                 //根据节点数组循环修改节点值
  204.                 for (int i = 0; i < XmlNode.Length; i++)
  205.                 {
  206.                     XmlDoc.SelectSingleNode(XmlParentNode+"/"+XmlNode[i]).InnerText = NodeContent[i];
  207.                 }
  208.                 return true;
  209.             }
  210.             catch
  211.             {
  212.                 return false;
  213.             }
  214.         }
  216.         /// <summary>
  217.         /// 修改属性
  218.         /// </summary>
  219.         /// <param name="XmlPathNode">属性所在的节点</param>
  220.         /// <param name="Attrib">属性名</param>
  221.         /// <param name="Content">属性值</param>
  222.         /// <returns></returns>
  223.         public bool UpdateAttrib(string XmlPathNode, string Attrib,string AttribContent)
  224.         {
  225.             try
  226.             {
  227.                 //修改属性值
  228.                 XmlDoc.SelectSingleNode(XmlPathNode).Attributes[Attrib].Value = AttribContent;
  229.                 return true;
  230.             }
  231.             catch
  232.             {
  233.                 return false;
  234.             }
  235.         }
  238.         /// <summary>
  239.         /// 添加属性
  240.         /// </summary>
  241.         /// <param name="MainNode">属性所在节点</param>
  242.         /// <param name="Attrib">属性名</param>
  243.         /// <param name="AttribContent">属性值</param>
  244.         /// <returns></returns>
  245.         public bool InsertAttrib(string MainNode,string Attrib, string AttribContent)
  246.         {
  247.             try
  248.             {
  249.                 XmlElement objNode = (XmlElement)XmlDoc.SelectSingleNode(MainNode); //强制转化成XmlElement对象
  250.                 objNode.SetAttribute(Attrib, AttribContent);    //XmlElement对象添加属性方法    
  251.                 return true;
  252.             }
  253.             catch
  254.             {
  255.                 return false;
  256.             }
  257.         }
  260.         /// <summary>
  261.         /// 插入一个节点，带N个子节点
  262.         /// </summary>
  263.         /// <param name="MainNode">插入节点的父节点</param>
  264.         /// <param name="ChildNode">插入节点的元素名</param>
  265.         /// <param name="Element">插入节点的子节点名数组</param>
  266.         /// <param name="Content">插入节点的子节点内容数组</param>
  267.         /// <returns></returns>
  268.         public bool InsertNode(string MainNode, string ChildNode, string[] Element, string[] Content)
  269.         {
  270.             try
  271.             {
  272.                 XmlNode objRootNode = XmlDoc.SelectSingleNode(MainNode);    //声明XmlNode对象
  273.                 XmlElement objChildNode = XmlDoc.CreateElement(ChildNode);  //创建XmlElement对象
  274.                 objRootNode.AppendChild(objChildNode);  
  275.                 for (int i = 0; i < Element.Length; i++)    //循环插入节点元素
  276.                 {
  277.                     XmlElement objElement = XmlDoc.CreateElement(Element[i]);
  278.                     objElement.InnerText = Content[i];
  279.                     objChildNode.AppendChild(objElement);
  280.                 }
  281.                 return true;
  282.             }
  283.             catch
  284.             {
  285.                 return false;
  286.             }
  287.         }
  289.         /// <summary>
  290.         /// 删除一个节点
  291.         /// </summary>
  292.         /// <param name="Node">要删除的节点</param>
  293.         /// <returns></returns>
  294.         public bool DeleteNode(string Node)
  295.         {
  296.             try
  297.             {
  298.                 //XmlNode的RemoveChild方法来删除节点及其所有子节点
  299.                 XmlDoc.SelectSingleNode(Node).ParentNode.RemoveChild(XmlDoc.SelectSingleNode(Node));
  300.                 return true;
  301.             }
  302.             catch
  303.             {
  304.                 return false;
  305.             }
  306.         }
  307.     }
  308. }
返回
【上篇】
【下篇】

作者:

抱歉!评论已关闭.

返回首页

Copyright © 2013-2018 学步园  保留所有权利.
软文销售 QQ客服：2265327166 点击这里给我发消息（其他合作也可洽谈）
必威体育
必威电竞