xml使用系统整理

1、 认识xml

可扩展标记语言，一种用于标记电子文档使其具有结果性的标记语言，它可以用来标记数据、定义数据类型，是一种允许用户对自己的标记语言进行定义的源语言。

2、 和超文本标记语言区别

2.1 html不一定需要成对出现，xml则一定需要成对出现。

2.2 html 不区分大小写，但是xml区分。

3、对xml文档增删改查

  //声明一个XmlDocument空对象
         protected XmlDocument XmlDoc = new XmlDocument();
         /// <summary>
         /// 构造函数，导入xml文件
         /// </summary>
         /// <param name="path"></param>
         public XmlHelper(string path)
         {
             try
             {
                 XmlDoc.Load(path);
             }
             catch (Exception ex)
             {
                 throw ex;
             }
         }
         /// <summary>
         /// 保存文件
         /// </summary>
         /// <param name="path"></param>
         public void SaveXml(string path)
         {
             try
             {
                 XmlDoc.Save(path);
             }
             catch (System.Exception ex)
             {
                 throw ex;
             }
         }

  /// <summary>
         /// 获取节点的子节点的内容
         /// </summary>
         /// <param name="path"></param>
         /// <param name="rootNode"></param>
         /// <param name="attributeName"></param>
         /// <returns></returns>
         public string GetNodeChildAttribute(string path, string rootNode, string attributeName)
         {
             XmlNode xn = XmlDoc.SelectSingleNode(rootNode);
             StringBuilder sb = new StringBuilder();
             XmlNodeList xnl = xn.ChildNodes;

             foreach (XmlNode xnf in xnl)
             {
                 XmlElement xe = (XmlElement)xnf;
                 XmlNodeList xnf1 = xe.ChildNodes;
                 foreach (XmlNode xn2 in xnf1)
                 {
                     if (xn2.Name == attributeName)
                     {
                         sb.Append(xn2.InnerText);//显示子节点点文本
                     }
                 }
             }
             return sb.ToString();
         }

 /// <summary>
         /// 获取节点的属性值
         /// </summary>
         /// <param name="path">xml路径</param>
         /// <param name="rootNode">根节点名称</param>
         /// <param name="attributeName">属性名称</param>
         /// <returns></returns>
         public string GetNodeAttribute(string path, string rootNode, string attributeName)
         {
             try
             {
                 XmlNode xn = XmlDoc.SelectSingleNode(rootNode);
                 XmlNodeList xnl = xn.ChildNodes;
                 StringBuilder sb = new StringBuilder();
                 foreach (XmlNode xnf in xnl)
                 {
                     XmlElement xe = (XmlElement)xnf;
                     sb.Append(xe.GetAttribute(attributeName));
                 }
                 return sb.ToString();
             }
             catch (Exception)
             {

                 throw;
             }
         }

  /// <summary>
         /// 删除节点/节点属性
         /// </summary>
         /// <param name="path">xml文件地址</param>
         /// <param name="rootNode">根节点名称</param>
         /// <param name="delNode">要删除的节点</param>
         /// <param name="attributeName">节点属性</param>
         /// <param name="attributeValue">属性值</param>
         public void DeleteNode(string path, string rootNode, string attributeName, string attributeValue)
         {
             try
             {
                 XmlNodeList xnl = XmlDoc.SelectSingleNode(rootNode).ChildNodes;
                 foreach (XmlNode xn in xnl)
                 {
                     XmlElement xe = (XmlElement)xn;
                     if (xe.GetAttribute(attributeName) == attributeValue)
                     {
                         //xe.RemoveAttribute(attributeName);//删除属性
                         xe.RemoveAll();//删除该节点的全部内容
                     }
                 }
                 SaveXml(path);
             }
             catch (Exception)
             {

                 throw;
             }
         }

  /// <summary>
         /// 修改节点的子节点内容
         /// </summary>
         /// <param name="path">xml文件路径</param>
         /// <param name="rootNode">根节点名称</param>
         /// <param name="attributeName">节点的子节点名称</param>
         /// <param name="attributeOldValue">节点的子节点原始内容</param>
         /// <param name="attributeNewValue">节点的子节点新内容</param>
         public void UpdateChildNodeAttribute(string path, string rootNode, string attributeName, string attributeOldValue, string attributeNewValue)
         {
             try
             {
                 XmlNodeList nodeList = XmlDoc.SelectSingleNode(rootNode).ChildNodes;//获取根节点的所有子节点
                 foreach (XmlNode xn in nodeList)//遍历所有子节点
                 {
                     XmlElement xe = (XmlElement)xn;//将子节点类型转换为XmlElement类型
                     if (string.IsNullOrEmpty(attributeName) || string.IsNullOrEmpty(attributeOldValue))
                     {
                         return;
                     }
                     else
                     {
                         XmlNodeList nls = xe.ChildNodes;
                         if (nls != null && nls.Count > )
                         {
                             foreach (XmlNode xn1 in nls)//遍历
                             {
                                 XmlElement xe2 = (XmlElement)xn1;//转换类型
                                 if (xe2.InnerText == attributeOldValue)//如果找到
                                 {
                                     xe2.InnerText = attributeNewValue;//则修改
                                     break;//找到退出来就可以了
                                 }
                             }
                         }
                     }
                 }
                 SaveXml(path);
             }
             catch (Exception)
             {

                 throw;
             }
         }

 /// <summary>
         /// 修改节点属性值操作
         /// </summary>
         /// <param name="path">xml文件路径</param>
         /// <param name="rootNode">根节点名称，如：bookstore</param>
         /// <param name="attributeName">节点属性名</param>
         /// <param name="attributeOldValue">节点属性原来值</param>
         /// <param name="attributeNewValue">节点属性修改后的值</param>
         public void UpdateNodeAttribute(string path, string rootNode, string attributeName, string attributeOldValue, string attributeNewValue)
         {
             try
             {
                 XmlNodeList nodeList = XmlDoc.SelectSingleNode(rootNode).ChildNodes;//获取根节点的所有子节点
                 foreach (XmlNode xn in nodeList)//遍历所有子节点
                 {
                     XmlElement xe = (XmlElement)xn;//将子节点类型专程xmlelement类型
                     if (string.IsNullOrEmpty(attributeName) || string.IsNullOrEmpty(attributeOldValue))
                     {
                         return;
                     }
                     else
                     {
                         if (xe.GetAttribute(attributeName) == attributeOldValue)
                         {
                             xe.SetAttribute(attributeName, attributeNewValue);
                         }
                     }
                 }
                 SaveXml(path);
             }
             catch (Exception)
             {

                 throw;
             }
         }

 /// <summary>
         /// 插入节点操作
         /// </summary>
         /// <param name="path">xml文件路径</param>
         /// <param name="rootNode">根节点名称，如：bookstore</param>
         /// <param name="node">节点名称，如：book</param>
         /// <param name="nodeAttributes">节点的属性-属性值集合</param>
         /// <param name="childAttributes">节点子节点名称-内容</param>
         public void InsertNode(string path, string rootNode, string node, Dictionary<string, string> nodeAttributes, Dictionary<string, string> childAttributes)
         {
             try
             {
                 XmlNode root = XmlDoc.SelectSingleNode(rootNode);//找到根节点bookstore
                 XmlElement xe1 = XmlDoc.CreateElement(node);//创建子节点book
                 if (nodeAttributes != null && nodeAttributes.Count > )
                 {
                     foreach (var n in nodeAttributes)
                     {
                         xe1.SetAttribute(n.Key, n.Value);
                     }
                 }
                 if (childAttributes != null && childAttributes.Count > )
                 {
                     XmlElement xesub1;
                     foreach (var n in childAttributes)
                     {
                         xesub1 = XmlDoc.CreateElement(n.Key);
                         xesub1.InnerText = n.Value;
                         xe1.AppendChild(xesub1);//添加到<book>节点中
                     }
                 }
                 root.AppendChild(xe1);
                 SaveXml(path);
             }
             catch (Exception)
             {

                 throw;
             }
         }

调用：

  string path = Server.MapPath("Books.xml");
             XmlHelper xHelper = new XmlHelper(path);
             /*插入*/
             //Dictionary<string, string> dc1 = new Dictionary<string, string>();
             //dc1.Add("genre", "李赞红");
             //dc1.Add("ISBN", "2-3631-4");
             //Dictionary<strin插入g, string> dc2 = new Dictionary<string, string>();
             //dc2.Add("title", "CS从入门到精通");
             //dc2.Add("author", "候捷");
             //dc2.Add("price", "58.3");
             //xHelper.InsertNode(path, "bookstore", "book", dc1, dc2);

             /*修改*/
             //xHelper.UpdateNodeAttribute(path, "bookstore", "genre", "李赞红", "李");
             //xHelper.UpdateChildNodeAttribute(path, "bookstore", "title", "CS从入门到精通", "cs");

             /*删除节点*/
             //xHelper.DeleteNode(path, "bookstore", "genre", "李");

             //Response.Write(xHelper.GetNodeAttribute(path, "bookstore", "genre"));
             //Response.Write(xHelper.GetNodeChildAttribute(path, "bookstore", "price"));

4、通过xml数据绑定

xml转DataTable

  public DataTable XmlToData(string path, string rootNode, params string[] columns)
         {
             DataTable dt = new DataTable();
             XmlNodeList xn = XmlDoc.SelectSingleNode(rootNode).ChildNodes;
             try
             {
                 if (columns.Length > )
                 {
                     DataColumn dc;
                     for (int i = ; i < columns.Length; i++)
                     {
                         dc = new DataColumn(columns[i]);
                         dt.Columns.Add(dc);
                     }
                     foreach (XmlNode xnf in xn)
                     {
                         XmlElement xe = (XmlElement)xnf;
                         XmlNodeList xnf1 = xe.ChildNodes;
                         int i = ;
                         DataRow dr = dt.NewRow();
                         foreach (XmlNode xn2 in xnf1)
                         {
                             dr[i] = xn2.InnerText;
                             i++;
                         }
                         dt.Rows.Add(dr);
                     }
                 }
             }
             catch (Exception)
             {

                 throw;
             }
             return dt;

         }

调用：

  //string[] arr = { "title", "author", "price" };
             //GridView1.DataSource = xHelper.XmlToData(path, "bookstore", arr);
             //GridView1.DataBind();

DataTable转xml

  /*datatable转xml*/
         public  string DataTableToXml(DataTable dt)
         {
             if (dt != null)
             {
                 MemoryStream ms = null;
                 XmlTextWriter XmlWt = null;
                 try
                 {
                     ms = new MemoryStream();
                     //根据ms实例化XmlWt
                     XmlWt = new XmlTextWriter(ms, Encoding.Unicode);
                     //获取ds中的数据
                     dt.WriteXml(XmlWt);
                     int count = (int)ms.Length;
                     byte[] temp = new byte[count];
                     ms.Seek(, SeekOrigin.Begin);
                     ms.Read(temp, , count);
                     //返回Unicode编码的文本
                     UnicodeEncoding ucode = new UnicodeEncoding();
                     string returnValue = ucode.GetString(temp).Trim();
                     return returnValue;
                 }
                 catch (System.Exception ex)
                 {
                     throw ex;
                 }
                 finally
                 {
                     //释放资源
                     if (XmlWt != null)
                     {
                         XmlWt.Close();
                         ms.Close();
                         ms.Dispose();
                     }
                 }
             }
             else
             {
                 return "";
             }
         }

调用：

  //bool s = xHelper.CDataToXmlFile(xHelper.XmlToData(path, "bookstore", arr), "Bookss.xml","book");

5、xml序列化反序列化

  [Serializable]
     public class Person
     {
         public string Name { get; set; }
         public int Age { get; set; }
     }

 public class CXmlSerializer<T> where T : new()
     {
         private static XmlSerializer _Serializer = new XmlSerializer(typeof(T));

         public static string Serialize(T t)
         {
             string s = "";
             using (MemoryStream ms = new MemoryStream())
             {
                 _Serializer.Serialize(ms, t);
                 s = System.Text.UTF8Encoding.UTF8.GetString(ms.ToArray());
             }
             return s;
         }

         public static T Deserialize(string s)
         {
             T t;
             using (MemoryStream ms = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(s)))
             {
                 t = (T)_Serializer.Deserialize(ms);
             }
             return t;
         }
     }

调用：

 List<Person> list = new List<Person> { new Person { Name = "Xuj", Age =  }, new Person { Name = "duj", Age =  }, new Person { Name = "fuj", Age =  } };
             string s = CXmlSerializer<List<Person>>.Serialize(list);