Eine ausführliche Einführung in die Zusammenfassung der Verwendung von XML

1. XML verstehen

Extensible Markup Language, eine Auszeichnungssprache, die zum Markieren elektronischer Dokumente verwendet werden kann, um sie ergebnisorientiert zu gestalten ermöglicht Benutzern die Verwendung einer Quellsprache, die ihre eigene Auszeichnungssprache definiert.

2. Unterschiede zur Hypertext-Auszeichnungssprache

2.1 HTML muss nicht unbedingt paarweise erscheinen, während XML paarweise erscheinen muss.

2.2 HTML unterscheidet nicht zwischen Groß- und Kleinschreibung, XML jedoch schon.

3. Auf Hinzufügungen, Löschungen und Änderungen von XML-Dokumenten prüfen

//声明一个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 > 0)
                       {
                           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 > 0)
                {
                    foreach (var n in nodeAttributes)
                    {
                        xe1.SetAttribute(n.Key, n.Value);
                    }
                }
                if (childAttributes != null && childAttributes.Count > 0)
                {
                    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;
            }
        }

Anruf:

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. Durch XML-Datenbindung

xml an 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 > 0)
               {
                   DataColumn dc;
                   for (int i = 0; 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 = 0;
                       DataRow dr = dt.NewRow();
                       foreach (XmlNode xn2 in xnf1)
                       {
                           dr[i] = xn2.InnerText;
                           i++;
                       }
                       dt.Rows.Add(dr);
                   }
               }
           }
           catch (Exception)
           {
 
               throw;
           }
           return dt;
 
       }

Aufruf:

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

DataTable an 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(0, SeekOrigin.Begin);
                   ms.Read(temp, 0, 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 "";
           }
       }

Aufruf:

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

5. XML-Serialisierung und -Deserialisierung

[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;
        }
    }

Aufruf:

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

Das obige ist der detaillierte Inhalt vonEine ausführliche Einführung in die Zusammenfassung der Verwendung von XML. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!