Code666 (代码贴、代码片段)

[C#] C#自定义处理xml数据的封装类 →→→→→进入此内容的聊天室

来自 , 2020-12-05, 写在 C#, 查看 107 次.
URL http://www.code666.cn/view/933670f1
  1. using System;
  2. using System.Data;
  3. using System.IO;
  4. using System.Xml;
  5.  
  6. namespace DotNet.Utilities
  7. {
  8.     public class XMLProcess
  9.     {
  10.         #region 构造函数
  11.         public XMLProcess()
  12.         { }
  13.  
  14.         public XMLProcess(string strPath)
  15.         {
  16.             this._XMLPath = strPath;
  17.         }
  18.         #endregion
  19.  
  20.         #region 公有属性
  21.         private string _XMLPath;
  22.         public string XMLPath
  23.         {
  24.             get { return this._XMLPath; }
  25.         }
  26.         #endregion
  27.  
  28.         #region 私有方法
  29.         /// <summary>
  30.         /// 导入XML文件
  31.         /// </summary>
  32.         /// <param name="XMLPath">XML文件路径</param>
  33.         private XmlDocument XMLLoad()
  34.         {
  35.             string XMLFile = XMLPath;
  36.             XmlDocument xmldoc = new XmlDocument();
  37.             try
  38.             {
  39.                 string filename = AppDomain.CurrentDomain.BaseDirectory.ToString() + XMLFile;
  40.                 if (File.Exists(filename)) xmldoc.Load(filename);
  41.             }
  42.             catch (Exception e)
  43.             { }
  44.             return xmldoc;
  45.         }
  46.  
  47.         /// <summary>
  48.         /// 导入XML文件
  49.         /// </summary>
  50.         /// <param name="XMLPath">XML文件路径</param>
  51.         private static XmlDocument XMLLoad(string strPath)
  52.         {
  53.             XmlDocument xmldoc = new XmlDocument();
  54.             try
  55.             {
  56.                 string filename = AppDomain.CurrentDomain.BaseDirectory.ToString() + strPath;
  57.                 if (File.Exists(filename)) xmldoc.Load(filename);
  58.             }
  59.             catch (Exception e)
  60.             { }
  61.             return xmldoc;
  62.         }
  63.  
  64.         /// <summary>
  65.         /// 返回完整路径
  66.         /// </summary>
  67.         /// <param name="strPath">Xml的路径</param>
  68.         private static string GetXmlFullPath(string strPath)
  69.         {
  70.             if (strPath.IndexOf(":") > 0)
  71.             {
  72.                 return strPath;
  73.             }
  74.             else
  75.             {
  76.                 return System.Web.HttpContext.Current.Server.MapPath(strPath);
  77.             }
  78.         }
  79.         #endregion
  80.  
  81.         #region 读取数据
  82.         /// <summary>
  83.         /// 读取指定节点的数据
  84.         /// </summary>
  85.         /// <param name="node">节点</param>
  86.         /// 使用示列:
  87.         /// XMLProsess.Read("/Node", "")
  88.         /// XMLProsess.Read("/Node/Element[@Attribute='Name']")
  89.         public string Read(string node)
  90.         {
  91.             string value = "";
  92.             try
  93.             {
  94.                 XmlDocument doc = XMLLoad();
  95.                 XmlNode xn = doc.SelectSingleNode(node);
  96.                 value = xn.InnerText;
  97.             }
  98.             catch { }
  99.             return value;
  100.         }
  101.  
  102.         /// <summary>
  103.         /// 读取指定路径和节点的串联值
  104.         /// </summary>
  105.         /// <param name="path">路径</param>
  106.         /// <param name="node">节点</param>
  107.         /// <param name="attribute">属性名，非空时返回该属性值，否则返回串联值</param>
  108.         /// 使用示列:
  109.         /// XMLProsess.Read(path, "/Node", "")
  110.         /// XMLProsess.Read(path, "/Node/Element[@Attribute='Name']")
  111.         public static string Read(string path, string node)
  112.         {
  113.             string value = "";
  114.             try
  115.             {
  116.                 XmlDocument doc = XMLLoad(path);
  117.                 XmlNode xn = doc.SelectSingleNode(node);
  118.                 value = xn.InnerText;
  119.             }
  120.             catch { }
  121.             return value;
  122.         }
  123.  
  124.         /// <summary>
  125.         /// 读取指定路径和节点的属性值
  126.         /// </summary>
  127.         /// <param name="path">路径</param>
  128.         /// <param name="node">节点</param>
  129.         /// <param name="attribute">属性名，非空时返回该属性值，否则返回串联值</param>
  130.         /// 使用示列:
  131.         /// XMLProsess.Read(path, "/Node", "")
  132.         /// XMLProsess.Read(path, "/Node/Element[@Attribute='Name']", "Attribute")
  133.         public static string Read(string path, string node, string attribute)
  134.         {
  135.             string value = "";
  136.             try
  137.             {
  138.                 XmlDocument doc = XMLLoad(path);
  139.                 XmlNode xn = doc.SelectSingleNode(node);
  140.                 value = (attribute.Equals("") ? xn.InnerText : xn.Attributes[attribute].Value);
  141.             }
  142.             catch { }
  143.             return value;
  144.         }
  145.  
  146.         /// <summary>
  147.         /// 获取某一节点的所有孩子节点的值
  148.         /// </summary>
  149.         /// <param name="node">要查询的节点</param>
  150.         public string[] ReadAllChildallValue(string node)
  151.         {
  152.             int i = 0;
  153.             string[] str = { };
  154.             XmlDocument doc = XMLLoad();
  155.             XmlNode xn = doc.SelectSingleNode(node);
  156.             XmlNodeList nodelist = xn.ChildNodes;  //得到该节点的子节点
  157.             if (nodelist.Count > 0)
  158.             {
  159.                 str = new string[nodelist.Count];
  160.                 foreach (XmlElement el in nodelist)//读元素值
  161.                 {
  162.                     str[i] = el.Value;
  163.                     i++;
  164.                 }
  165.             }
  166.             return str;
  167.         }
  168.  
  169.         /// <summary>
  170.         /// 获取某一节点的所有孩子节点的值
  171.         /// </summary>
  172.         /// <param name="node">要查询的节点</param>
  173.         public XmlNodeList ReadAllChild(string node)
  174.         {
  175.             XmlDocument doc = XMLLoad();
  176.             XmlNode xn = doc.SelectSingleNode(node);
  177.             XmlNodeList nodelist = xn.ChildNodes;  //得到该节点的子节点
  178.             return nodelist;
  179.         }
  180.  
  181.         /// <summary>
  182.         /// 读取XML返回经排序或筛选后的DataView
  183.         /// </summary>
  184.         /// <param name="strWhere">筛选条件，如:"name='kgdiwss'"</param>
  185.         /// <param name="strSort"> 排序条件，如:"Id desc"</param>
  186.         public DataView GetDataViewByXml(string strWhere, string strSort)
  187.         {
  188.             try
  189.             {
  190.                 string XMLFile = this.XMLPath;
  191.                 string filename = AppDomain.CurrentDomain.BaseDirectory.ToString() + XMLFile;
  192.                 DataSet ds = new DataSet();
  193.                 ds.ReadXml(filename);
  194.                 DataView dv = new DataView(ds.Tables[0]); //创建DataView来完成排序或筛选操作       
  195.                 if (strSort != null)
  196.                 {
  197.                     dv.Sort = strSort; //对DataView中的记录进行排序
  198.                 }
  199.                 if (strWhere != null)
  200.                 {
  201.                     dv.RowFilter = strWhere; //对DataView中的记录进行筛选，找到我们想要的记录
  202.                 }
  203.                 return dv;
  204.             }
  205.             catch (Exception)
  206.             {
  207.                 return null;
  208.             }
  209.         }
  210.  
  211.         /// <summary>
  212.         /// 读取XML返回DataSet
  213.         /// </summary>
  214.         /// <param name="strXmlPath">XML文件相对路径</param>
  215.         public DataSet GetDataSetByXml(string strXmlPath)
  216.         {
  217.             try
  218.             {
  219.                 DataSet ds = new DataSet();
  220.                 ds.ReadXml(GetXmlFullPath(strXmlPath));
  221.                 if (ds.Tables.Count > 0)
  222.                 {
  223.                     return ds;
  224.                 }
  225.                 return null;
  226.             }
  227.             catch (Exception)
  228.             {
  229.                 return null;
  230.             }
  231.         }
  232.         #endregion
  233.  
  234.         #region 插入数据
  235.         /// <summary>
  236.         /// 插入数据
  237.         /// </summary>
  238.         /// <param name="path">路径</param>
  239.         /// <param name="node">节点</param>
  240.         /// <param name="element">元素名，非空时插入新元素，否则在该元素中插入属性</param>
  241.         /// <param name="attribute">属性名，非空时插入该元素属性值，否则插入元素值</param>
  242.         /// <param name="value">值</param>
  243.         /// 使用示列:
  244.         /// XMLProsess.Insert(path, "/Node", "Element", "", "Value")
  245.         /// XMLProsess.Insert(path, "/Node", "Element", "Attribute", "Value")
  246.         /// XMLProsess.Insert(path, "/Node", "", "Attribute", "Value")
  247.         public static void Insert(string path, string node, string element, string attribute, string value)
  248.         {
  249.             try
  250.             {
  251.                 XmlDocument doc = new XmlDocument();
  252.                 doc.Load(AppDomain.CurrentDomain.BaseDirectory.ToString() + path);
  253.                 XmlNode xn = doc.SelectSingleNode(node);
  254.                 if (element.Equals(""))
  255.                 {
  256.                     if (!attribute.Equals(""))
  257.                     {
  258.                         XmlElement xe = (XmlElement)xn;
  259.                         xe.SetAttribute(attribute, value);
  260.                     }
  261.                 }
  262.                 else
  263.                 {
  264.                     XmlElement xe = doc.CreateElement(element);
  265.                     if (attribute.Equals(""))
  266.                         xe.InnerText = value;
  267.                     else
  268.                         xe.SetAttribute(attribute, value);
  269.                     xn.AppendChild(xe);
  270.                 }
  271.                 doc.Save(AppDomain.CurrentDomain.BaseDirectory.ToString() + path);
  272.             }
  273.             catch { }
  274.         }
  275.  
  276.         /// <summary>
  277.         /// 插入数据
  278.         /// </summary>
  279.         /// <param name="path">路径</param>
  280.         /// <param name="node">节点</param>
  281.         /// <param name="element">元素名，非空时插入新元素，否则在该元素中插入属性</param>
  282.         /// <param name="strList">由XML属性名和值组成的二维数组</param>
  283.         public static void Insert(string path, string node, string element, string[][] strList)
  284.         {
  285.             try
  286.             {
  287.                 XmlDocument doc = new XmlDocument();
  288.                 doc.Load(AppDomain.CurrentDomain.BaseDirectory.ToString() + path);
  289.                 XmlNode xn = doc.SelectSingleNode(node);
  290.                 XmlElement xe = doc.CreateElement(element);
  291.                 string strAttribute = "";
  292.                 string strValue = "";
  293.                 for (int i = 0; i < strList.Length; i++)
  294.                 {
  295.                     for (int j = 0; j < strList[i].Length; j++)
  296.                     {
  297.                         if (j == 0)
  298.                             strAttribute = strList[i][j];
  299.                         else
  300.                             strValue = strList[i][j];
  301.                     }
  302.                     if (strAttribute.Equals(""))
  303.                         xe.InnerText = strValue;
  304.                     else
  305.                         xe.SetAttribute(strAttribute, strValue);
  306.                 }
  307.                 xn.AppendChild(xe);
  308.                 doc.Save(AppDomain.CurrentDomain.BaseDirectory.ToString() + path);
  309.             }
  310.             catch { }
  311.         }
  312.  
  313.         /// <summary>
  314.         /// 插入一行数据
  315.         /// </summary>
  316.         /// <param name="strXmlPath">XML文件相对路径</param>
  317.         /// <param name="Columns">要插入行的列名数组，如：string[] Columns = {"name","IsMarried"};</param>
  318.         /// <param name="ColumnValue">要插入行每列的值数组，如：string[] ColumnValue={"XML大全","false"};</param>
  319.         /// <returns>成功返回true,否则返回false</returns>
  320.         public static bool WriteXmlByDataSet(string strXmlPath, string[] Columns, string[] ColumnValue)
  321.         {
  322.             try
  323.             {
  324.                 //根据传入的XML路径得到.XSD的路径，两个文件放在同一个目录下
  325.                 string strXsdPath = strXmlPath.Substring(0, strXmlPath.IndexOf(".")) + ".xsd";
  326.                 DataSet ds = new DataSet();
  327.                 ds.ReadXmlSchema(GetXmlFullPath(strXsdPath)); //读XML架构，关系到列的数据类型
  328.                 ds.ReadXml(GetXmlFullPath(strXmlPath));
  329.                 DataTable dt = ds.Tables[0];
  330.                 DataRow newRow = dt.NewRow();                 //在原来的表格基础上创建新行
  331.                 for (int i = 0; i < Columns.Length; i++)      //循环给一行中的各个列赋值
  332.                 {
  333.                     newRow[Columns[i]] = ColumnValue[i];
  334.                 }
  335.                 dt.Rows.Add(newRow);
  336.                 dt.AcceptChanges();
  337.                 ds.AcceptChanges();
  338.                 ds.WriteXml(GetXmlFullPath(strXmlPath));
  339.                 return true;
  340.             }
  341.             catch (Exception)
  342.             {
  343.                 return false;
  344.             }
  345.         }
  346.         #endregion
  347.  
  348.         #region 修改数据
  349.         /// <summary>
  350.         /// 修改指定节点的数据
  351.         /// </summary>
  352.         /// <param name="node">节点</param>
  353.         /// <param name="value">值</param>
  354.         public void Update(string node, string value)
  355.         {
  356.             try
  357.             {
  358.                 XmlDocument doc = XMLLoad();
  359.                 XmlNode xn = doc.SelectSingleNode(node);
  360.                 xn.InnerText = value;
  361.                 doc.Save(AppDomain.CurrentDomain.BaseDirectory.ToString() + XMLPath);
  362.             }
  363.             catch { }
  364.         }
  365.  
  366.         /// <summary>
  367.         /// 修改指定节点的数据
  368.         /// </summary>
  369.         /// <param name="path">路径</param>
  370.         /// <param name="node">节点</param>
  371.         /// <param name="value">值</param>
  372.         /// 使用示列:
  373.         /// XMLProsess.Insert(path, "/Node","Value")
  374.         /// XMLProsess.Insert(path, "/Node","Value")
  375.         public static void Update(string path, string node, string value)
  376.         {
  377.             try
  378.             {
  379.                 XmlDocument doc = XMLLoad(path);
  380.                 XmlNode xn = doc.SelectSingleNode(node);
  381.                 xn.InnerText = value;
  382.                 doc.Save(AppDomain.CurrentDomain.BaseDirectory.ToString() + path);
  383.             }
  384.             catch { }
  385.         }
  386.  
  387.         /// <summary>
  388.         /// 修改指定节点的属性值(静态)
  389.         /// </summary>
  390.         /// <param name="path">路径</param>
  391.         /// <param name="node">节点</param>
  392.         /// <param name="attribute">属性名，非空时修改该节点属性值，否则修改节点值</param>
  393.         /// <param name="value">值</param>
  394.         /// 使用示列:
  395.         /// XMLProsess.Insert(path, "/Node", "", "Value")
  396.         /// XMLProsess.Insert(path, "/Node", "Attribute", "Value")
  397.         public static void Update(string path, string node, string attribute, string value)
  398.         {
  399.             try
  400.             {
  401.                 XmlDocument doc = XMLLoad(path);
  402.                 XmlNode xn = doc.SelectSingleNode(node);
  403.                 XmlElement xe = (XmlElement)xn;
  404.                 if (attribute.Equals(""))
  405.                     xe.InnerText = value;
  406.                 else
  407.                     xe.SetAttribute(attribute, value);
  408.                 doc.Save(AppDomain.CurrentDomain.BaseDirectory.ToString() + path);
  409.             }
  410.             catch { }
  411.         }
  412.  
  413.         /// <summary>
  414.         /// 更改符合条件的一条记录
  415.         /// </summary>
  416.         /// <param name="strXmlPath">XML文件路径</param>
  417.         /// <param name="Columns">列名数组</param>
  418.         /// <param name="ColumnValue">列值数组</param>
  419.         /// <param name="strWhereColumnName">条件列名</param>
  420.         /// <param name="strWhereColumnValue">条件列值</param>
  421.         public static bool UpdateXmlRow(string strXmlPath, string[] Columns, string[] ColumnValue, string strWhereColumnName, string strWhereColumnValue)
  422.         {
  423.             try
  424.             {
  425.                 string strXsdPath = strXmlPath.Substring(0, strXmlPath.IndexOf(".")) + ".xsd";
  426.                 DataSet ds = new DataSet();
  427.                 ds.ReadXmlSchema(GetXmlFullPath(strXsdPath));//读XML架构，关系到列的数据类型
  428.                 ds.ReadXml(GetXmlFullPath(strXmlPath));
  429.  
  430.                 //先判断行数
  431.                 if (ds.Tables[0].Rows.Count > 0)
  432.                 {
  433.                     for (int i = 0; i < ds.Tables[0].Rows.Count; i++)
  434.                     {
  435.                         //如果当前记录为符合Where条件的记录
  436.                         if (ds.Tables[0].Rows[i][strWhereColumnName].ToString().Trim().Equals(strWhereColumnValue))
  437.                         {
  438.                             //循环给找到行的各列赋新值
  439.                             for (int j = 0; j < Columns.Length; j++)
  440.                             {
  441.                                 ds.Tables[0].Rows[i][Columns[j]] = ColumnValue[j];
  442.                             }
  443.                             ds.AcceptChanges();                     //更新DataSet
  444.                             ds.WriteXml(GetXmlFullPath(strXmlPath));//重新写入XML文件
  445.                             return true;
  446.                         }
  447.                     }
  448.  
  449.                 }
  450.                 return false;
  451.             }
  452.             catch (Exception)
  453.             {
  454.                 return false;
  455.             }
  456.         }
  457.         #endregion
  458.  
  459.         #region 删除数据
  460.         /// <summary>
  461.         /// 删除节点值
  462.         /// </summary>
  463.         /// <param name="path">路径</param>
  464.         /// <param name="node">节点</param>
  465.         /// <param name="attribute">属性名，非空时删除该节点属性值，否则删除节点值</param>
  466.         /// <param name="value">值</param>
  467.         /// 使用示列:
  468.         /// XMLProsess.Delete(path, "/Node", "")
  469.         /// XMLProsess.Delete(path, "/Node", "Attribute")
  470.         public static void Delete(string path, string node)
  471.         {
  472.             try
  473.             {
  474.                 XmlDocument doc = XMLLoad(path);
  475.                 XmlNode xn = doc.SelectSingleNode(node);
  476.                 xn.ParentNode.RemoveChild(xn);
  477.                 doc.Save(AppDomain.CurrentDomain.BaseDirectory.ToString() + path);
  478.             }
  479.             catch { }
  480.         }
  481.  
  482.         /// <summary>
  483.         /// 删除数据
  484.         /// </summary>
  485.         /// <param name="path">路径</param>
  486.         /// <param name="node">节点</param>
  487.         /// <param name="attribute">属性名，非空时删除该节点属性值，否则删除节点值</param>
  488.         /// <param name="value">值</param>
  489.         /// 使用示列:
  490.         /// XMLProsess.Delete(path, "/Node", "")
  491.         /// XMLProsess.Delete(path, "/Node", "Attribute")
  492.         public static void Delete(string path, string node, string attribute)
  493.         {
  494.             try
  495.             {
  496.                 XmlDocument doc = XMLLoad(path);
  497.                 XmlNode xn = doc.SelectSingleNode(node);
  498.                 XmlElement xe = (XmlElement)xn;
  499.                 if (attribute.Equals(""))
  500.                     xn.ParentNode.RemoveChild(xn);
  501.                 else
  502.                     xe.RemoveAttribute(attribute);
  503.                 doc.Save(AppDomain.CurrentDomain.BaseDirectory.ToString() + path);
  504.             }
  505.             catch { }
  506.         }
  507.  
  508.         /// <summary>
  509.         /// 删除所有行
  510.         /// </summary>
  511.         /// <param name="strXmlPath">XML路径</param>
  512.         public static bool DeleteXmlAllRows(string strXmlPath)
  513.         {
  514.             try
  515.             {
  516.                 DataSet ds = new DataSet();
  517.                 ds.ReadXml(GetXmlFullPath(strXmlPath));
  518.                 if (ds.Tables[0].Rows.Count > 0)
  519.                 {
  520.                     ds.Tables[0].Rows.Clear();
  521.                 }
  522.                 ds.WriteXml(GetXmlFullPath(strXmlPath));
  523.                 return true;
  524.             }
  525.             catch (Exception)
  526.             {
  527.                 return false;
  528.             }
  529.         }
  530.  
  531.         /// <summary>
  532.         /// 通过删除DataSet中指定索引行，重写XML以实现删除指定行
  533.         /// </summary>
  534.         /// <param name="iDeleteRow">要删除的行在DataSet中的Index值</param>
  535.         public static bool DeleteXmlRowByIndex(string strXmlPath, int iDeleteRow)
  536.         {
  537.             try
  538.             {
  539.                 DataSet ds = new DataSet();
  540.                 ds.ReadXml(GetXmlFullPath(strXmlPath));
  541.                 if (ds.Tables[0].Rows.Count > 0)
  542.                 {
  543.                     ds.Tables[0].Rows[iDeleteRow].Delete();
  544.                 }
  545.                 ds.WriteXml(GetXmlFullPath(strXmlPath));
  546.                 return true;
  547.             }
  548.             catch (Exception)
  549.             {
  550.                 return false;
  551.             }
  552.         }
  553.  
  554.         /// <summary>
  555.         /// 删除指定列中指定值的行
  556.         /// </summary>
  557.         /// <param name="strXmlPath">XML相对路径</param>
  558.         /// <param name="strColumn">列名</param>
  559.         /// <param name="ColumnValue">指定值</param>
  560.         public static bool DeleteXmlRows(string strXmlPath, string strColumn, string[] ColumnValue)
  561.         {
  562.             try
  563.             {
  564.                 DataSet ds = new DataSet();
  565.                 ds.ReadXml(GetXmlFullPath(strXmlPath));
  566.                 if (ds.Tables[0].Rows.Count > 0)
  567.                 {
  568.                     //判断行多还是删除的值多，多的for循环放在里面
  569.                     if (ColumnValue.Length > ds.Tables[0].Rows.Count)
  570.                     {
  571.                         for (int i = 0; i < ds.Tables[0].Rows.Count; i++)
  572.                         {
  573.                             for (int j = 0; j < ColumnValue.Length; j++)
  574.                             {
  575.                                 if (ds.Tables[0].Rows[i][strColumn].ToString().Trim().Equals(ColumnValue[j]))
  576.                                 {
  577.                                     ds.Tables[0].Rows[i].Delete();
  578.                                 }
  579.                             }
  580.                         }
  581.                     }
  582.                     else
  583.                     {
  584.                         for (int j = 0; j < ColumnValue.Length; j++)
  585.                         {
  586.                             for (int i = 0; i < ds.Tables[0].Rows.Count; i++)
  587.                             {
  588.                                 if (ds.Tables[0].Rows[i][strColumn].ToString().Trim().Equals(ColumnValue[j]))
  589.                                 {
  590.                                     ds.Tables[0].Rows[i].Delete();
  591.                                 }
  592.                             }
  593.                         }
  594.                     }
  595.                     ds.WriteXml(GetXmlFullPath(strXmlPath));
  596.                 }
  597.                 return true;
  598.             }
  599.             catch (Exception)
  600.             {
  601.                 return false;
  602.             }
  603.         }
  604.         #endregion
  605.     }
  606. }
  607. //csharp/8621

回复 "C#自定义处理xml数据的封装类"

这儿你可以回复上面这条便签

captcha

贴代码片段 - Code666