.NET操作Xml类

 using System;
 using System.Collections.Generic;
 using System.Text;
 using System.Data;
 using System.IO;
 using System.Xml;

 namespace Comm
 {
     /// <summary>
     /// Xml类
     /// </summary>
     public class CustomXmlDocument
     {
         /// <summary>
         /// 将Xml转成 dataset
         /// </summary>
         /// <param name="xmlfilepath">Xml文件全路径</param>
         /// <returns>dataset</returns>
         public static DataSet getDataset(string xmlfilepath)
         {
             bool flag = File.Exists(xmlfilepath);
             if (!flag)
             {
                 return null;
             }
             DataSet ds = new DataSet();
             try
             {
                 ds.ReadXml(xmlfilepath);
             }
             catch
             {
                 return null;
             }
             return ds;
         }

         /// <summary>
         /// 将Xml转成 datatable
         /// </summary>
         /// <param name="xmlfilepath">Xml文件全路径</param>
         /// <returns>datatable</returns>
         public static DataTable getDatatable(string xmlfilepath)
         {
             DataSet ds = getDataset(xmlfilepath);
             if (ds == null || ds.Tables.Count < )
             {
                 return null;
             }
             return ds.Tables[];
         }

         /// <summary>
         /// 获取 dataset
         /// </summary>
         /// <param name="xmlcontent">Xml内容</param>
         /// <returns>dataset</returns>
         public static DataSet getDatasetBycontent(string xmlcontent)
         {
             DataSet ds = null;
             try
             {
                 StringReader stringReader = new StringReader(xmlcontent);
                 XmlTextReader xmlTextReader = new XmlTextReader(stringReader);
                 ds = new DataSet();
                 ds.ReadXmlSchema(xmlTextReader);
             }
             catch
             {
                 return null;
             }

             return ds;
         }

         /// <summary>
         /// 获取 datatable
         /// </summary>
         /// <param name="xmlcontent">Xml内容</param>
         /// <returns>datatable</returns>
         public static DataTable getDatatableBycontent(string xmlcontent)
         {
             DataSet ds = getDatasetBycontent(xmlcontent);
             if (ds == null || ds.Tables.Count < )
             {
                 return null;
             }

             return ds.Tables[];
         }

         /// <summary>
         /// 将 xmlcontent 写成 Xml文件
         /// </summary>
         /// <param name="xmlcontent">Xml内容</param>
         /// <returns>保存Xml全路径</returns>
         public static string writeXmlByxmlcontent(string xmlcontent, string savefilepath)
         {
             try
             {
                 File.WriteAllText(savefilepath, xmlcontent);
             }
             catch
             {
                 return "";
             }
             return savefilepath;
         }

         /// <summary>
         /// 将 dataset 写成 Xml文件
         /// </summary>
         /// <param name="ds">dataset</param>
         /// <param name="savefilepath">保存Xml全路径</param>
         /// <returns>保存Xml全路径</returns>
         public static string writeXmlBydataset(DataSet ds, string savefilepath)
         {
             string[] columns = new string[ds.Tables[].Columns.Count];
             for (int i = ; i < ds.Tables[].Columns.Count; i++)
             {
                 columns[i] = ds.Tables[].Columns[i].ColumnName;
             }
             return writeXmlBydatatable(ds.Tables[], savefilepath, columns);
         }

         /// <summary>
         /// 将 datatable 写成 Xml文件
         /// </summary>
         /// <param name="dt">datatable</param>
         /// <param name="savefilepath">保存Xml全路径</param>
         /// <returns>保存Xml全路径</returns>
         public static string writeXmlBydatatable(DataTable dt, string savefilepath,string[] columns)
         {
             try
             {
                 System.Xml.XmlDocument xmlDoc = new System.Xml.XmlDocument();
                 XmlDeclaration xmldecl;
                 xmldecl = xmlDoc.CreateXmlDeclaration("1.0", null, null);
                 xmldecl.Encoding = "UTF-8";
                 xmldecl.Standalone = "yes";
                 XmlElement xmlElem = xmlDoc.CreateElement("table");
                 xmlDoc.InsertBefore(xmldecl, xmlElem);

                 if (columns == null || columns.Length < )
                 {
                     return "";
                 }

                 foreach (DataRow row in dt.Rows)
                 {
                     XmlElement xmlElemrow = xmlDoc.CreateElement("row");
                     foreach (string column in columns)
                     {
                         XmlElement xmlElemcolum = xmlDoc.CreateElement(column);
                         xmlElemcolum.Value = row[column].ToString().Trim();
                         xmlElemrow.AppendChild(xmlElemcolum);
                     }
                     xmlElem.AppendChild(xmlElemrow);
                 }
             }
             catch
             {
                 return "";
             }

             return savefilepath;

         }
     }
 }

 using System;
 using System.Collections.Generic;
 using System.Text;
 using System.Xml;
 using System.Collections;

 namespace Comm
 {
     public class XMLHelper
     {
         #region private AppendChild
         private static void AppendChild(XmlDocument xDoc, XmlNode parentNode, params XmlParameter[] paras)
         {
             foreach (XmlParameter xpar in paras)
             {
                 XmlNode newNode = xDoc.CreateNode(XmlNodeType.Element, xpar.Name, null);
                 string ns = xpar.NamespaceOfPrefix == null ? "" : newNode.GetNamespaceOfPrefix(xpar.NamespaceOfPrefix);
                 foreach (AttributeParameter attp in xpar.Attributes)
                 {
                     XmlNode attr = xDoc.CreateNode(XmlNodeType.Attribute, attp.Name, ns == "" ? null : ns);
                     attr.Value = attp.Value;
                     newNode.Attributes.SetNamedItem(attr);
                 }
                 newNode.InnerText = xpar.InnerText;
                 parentNode.AppendChild(newNode);
             }
         }
         #endregion

         #region private AddEveryNode
         private static void AddEveryNode(XmlDocument xDoc, XmlNode parentNode, params XmlParameter[] paras)
         {
             XmlNodeList nlst = xDoc.DocumentElement.ChildNodes;
             foreach (XmlNode xns in nlst)
             {
                 if (xns.Name == parentNode.Name)
                 {
                     AppendChild(xDoc, xns, paras);
                 }
                 else
                 {
                     foreach (XmlNode xn in xns)
                     {
                         if (xn.Name == parentNode.Name)
                         {
                             AppendChild(xDoc, xn, paras);
                         }
                     }
                 }
             }
         }
         #endregion

         #region xmlDoc
         /// <summary>
         /// 创建一个XmlDocument对象
         /// </summary>
         /// <param name="PathOrString">文件名称或XML字符串</param>
         public static XmlDocument xmlDoc(string PathOrString)
         {
             try
             {
                 XmlDocument xDoc = new XmlDocument();
                 if (System.IO.File.Exists(PathOrString))
                 {
                     xDoc.Load(PathOrString);
                 }
                 else
                 {
                     xDoc.LoadXml(PathOrString);
                 }
                 return xDoc;
             }
             catch
             {
                 return null;
             }
         }
         #endregion

         #region CreateXMLFile
         /// <summary>
         /// 创建一个XML文档
         /// </summary>
         /// <param name="fileFullName">文件名称，包括完整路径</param>
         /// <param name="rootName">根结点名称</param>
         /// <param name="elemName">元素节点名称</param>
         /// <param name="paras">XML参数</param>
         public static void CreateXMLFile(string fileFullName, string rootName, string elemName, params XmlParameter[] paras)
         {
             XmlDocument xDoc = new XmlDocument();
             XmlNode xn;
             xn = xDoc.CreateXmlDeclaration("1.0", "UTF-8", null);
             xDoc.AppendChild(xn);
             XmlNode root = xDoc.CreateElement(rootName);
             xDoc.AppendChild(root);
             XmlNode ln = xDoc.CreateNode(XmlNodeType.Element, elemName, null);
             AppendChild(xDoc, ln, paras);
             root.AppendChild(ln);
             try
             {
                 xDoc.Save(fileFullName);
             }
             catch
             {
                 throw;
             }
         }
         /// <summary>
         /// 创建一个XML文档
         /// </summary>
         /// <param name="fileFullName">文件名称，包括完整路径</param>
         /// <param name="rootName">根结点名称</param>
         /// <param name="elemp">元素节点对象</param>
         /// <param name="paras">XML参数</param>
         public static void CreateXMLFile(string fileFullName, string rootName, XmlParameter elemp, params XmlParameter[] paras)
         {
             XmlDocument xDoc = new XmlDocument();
             XmlNode xn;
             xn = xDoc.CreateXmlDeclaration("1.0", "UTF-8", null);
             xDoc.AppendChild(xn);
             XmlNode root = xDoc.CreateElement(rootName);
             xDoc.AppendChild(root);
             XmlNode ln = xDoc.CreateNode(XmlNodeType.Element, elemp.Name, null);
             string ns = elemp.NamespaceOfPrefix == null ? "" : ln.GetNamespaceOfPrefix(elemp.NamespaceOfPrefix);
             foreach (AttributeParameter ap in elemp.Attributes)
             {
                 XmlNode elemAtt = xDoc.CreateNode(XmlNodeType.Attribute, ap.Name, ns == "" ? null : ns);
                 elemAtt.Value = ap.Value;
                 ln.Attributes.SetNamedItem(elemAtt);
             }
             AppendChild(xDoc, ln, paras);
             root.AppendChild(ln);
             try
             {
                 xDoc.Save(fileFullName);
             }
             catch
             {
                 throw;
             }
         }
         /// <summary>
         /// 创建一个XML文档
         /// </summary>
         /// <param name="fileFullName">文件名称，包括完整路径</param>
         /// <param name="rootp">根结点对象</param>
         /// <param name="elemName">元素节点名称</param>
         /// <param name="paras">XML参数</param>
         public static void CreateXMLFile(string fileFullName, XmlParameter rootp, string elemName, params XmlParameter[] paras)
         {
             XmlDocument xDoc = new XmlDocument();
             XmlNode xn;
             xn = xDoc.CreateXmlDeclaration("1.0", "UTF-8", null);
             xDoc.AppendChild(xn);
             XmlNode root = xDoc.CreateElement(rootp.Name);
             string ns = rootp.NamespaceOfPrefix == null ? "" : root.GetNamespaceOfPrefix(rootp.NamespaceOfPrefix);
             foreach (AttributeParameter ap in rootp.Attributes)
             {
                 XmlNode rootAtt = xDoc.CreateNode(XmlNodeType.Attribute, ap.Name, ns == "" ? null : ns);
                 rootAtt.Value = ap.Value;
                 root.Attributes.SetNamedItem(rootAtt);
             }
             xDoc.AppendChild(root);
             XmlNode ln = xDoc.CreateNode(XmlNodeType.Element, elemName, null);
             AppendChild(xDoc, ln, paras);
             root.AppendChild(ln);
             try
             {
                 xDoc.Save(fileFullName);
             }
             catch
             {
                 throw;
             }
         }
         /// <summary>
         /// 创建一个XML文档
         /// </summary>
         /// <param name="fileFullName">文件名称，包括完整路径</param>
         /// <param name="rootp">根结点对象</param>
         /// <param name="elemp">元素节点对象</param>
         /// <param name="paras">XML参数</param>
         public static void CreateXMLFile(string fileFullName, XmlParameter rootp, XmlParameter elemp, params XmlParameter[] paras)
         {
             XmlDocument xDoc = new XmlDocument();
             XmlNode xn;
             xn = xDoc.CreateXmlDeclaration("1.0", "UTF-8", null);
             xDoc.AppendChild(xn);
             XmlNode root = xDoc.CreateElement(rootp.Name);
             string ns = rootp.NamespaceOfPrefix == null ? "" : root.GetNamespaceOfPrefix(rootp.NamespaceOfPrefix);
             foreach (AttributeParameter ap in rootp.Attributes)
             {
                 XmlNode rootAtt = xDoc.CreateNode(XmlNodeType.Attribute, ap.Name, ns == "" ? null : ns);
                 rootAtt.Value = ap.Value;
                 root.Attributes.SetNamedItem(rootAtt);
             }
             xDoc.AppendChild(root);
             XmlNode ln = xDoc.CreateNode(XmlNodeType.Element, elemp.Name, null);
             ns = elemp.NamespaceOfPrefix == null ? "" : ln.GetNamespaceOfPrefix(elemp.NamespaceOfPrefix);
             foreach (AttributeParameter ap in elemp.Attributes)
             {
                 XmlNode elemAtt = xDoc.CreateNode(XmlNodeType.Attribute, ap.Name, ns == "" ? null : ns);
                 elemAtt.Value = ap.Value;
                 ln.Attributes.SetNamedItem(elemAtt);
             }
             AppendChild(xDoc, ln, paras);
             root.AppendChild(ln);
             try
             {
                 xDoc.Save(fileFullName);
             }
             catch
             {
                 throw;
             }
         }
         #endregion

         #region AddNewNode
         /// <summary>
         /// 添加新节点
         /// </summary>
         /// <param name="fileFullName">文件名称，包括完整路径</param>
         /// <param name="parentNode">新节点的父节点对象</param>
         /// <param name="paras">XML参数对象</param>
         public static bool AddNewNode(string fileFullName, XmlNode parentNode, params XmlParameter[] paras)
         {
             XmlDocument xDoc = xmlDoc(fileFullName);
             if (parentNode.Name == xDoc.DocumentElement.Name)
             {
                 XmlNode newNode = xDoc.CreateNode(XmlNodeType.Element, xDoc.DocumentElement.ChildNodes[].Name, null);
                 AppendChild(xDoc, newNode, paras);
                 xDoc.DocumentElement.AppendChild(newNode);
             }
             else
             {
                 AddEveryNode(xDoc, parentNode, paras);
             }
             xDoc.Save(fileFullName);
             return true;
         }
         /// <summary>
         /// 添加新节点
         /// </summary>
         /// <param name="xDoc">XmlDocument对象</param>
         /// <param name="parentNode">新节点的父节点对象</param>
         /// <param name="paras">XML参数对象</param>
         public static bool AddNewNode(XmlDocument xDoc, XmlNode parentNode, params XmlParameter[] paras)
         {
             if (parentNode.Name == xDoc.DocumentElement.Name)
             {
                 XmlNode newNode = xDoc.CreateNode(XmlNodeType.Element, xDoc.DocumentElement.ChildNodes[].Name, null);
                 AppendChild(xDoc, newNode, paras);
                 xDoc.DocumentElement.AppendChild(newNode);
             }
             else
             {
                 AddEveryNode(xDoc, parentNode, paras);
             }
             return true;
         }
         /// <summary>
         /// 添加新节点
         /// </summary>
         /// <param name="xDoc">XmlDocument对象</param>
         /// <param name="parentName">新节点的父节点名称</param>
         /// <param name="paras">XML参数对象</param>
         public static bool AddNewNode(XmlDocument xDoc, string parentName, params XmlParameter[] paras)
         {
             XmlNode parentNode = GetNode(xDoc, parentName);
             if (parentNode == null) return false;
             if (parentNode.Name == xDoc.DocumentElement.Name)
             {
                 XmlNode newNode = xDoc.CreateNode(XmlNodeType.Element, xDoc.DocumentElement.ChildNodes[].Name, null);
                 AppendChild(xDoc, newNode, paras);
                 xDoc.DocumentElement.AppendChild(newNode);
             }
             else
             {
                 AddEveryNode(xDoc, parentNode, paras);
             }
             return true;
         }
         /// <summary>
         /// 添加新节点
         /// </summary>
         /// <param name="fileFullName">文件名称，包括完整路径</param>
         /// <param name="parentName">新节点的父节点名称</param>
         /// <param name="paras">XML参数对象</param>
         public static bool AddNewNode(string fileFullName, string parentName, params XmlParameter[] paras)
         {
             XmlDocument xDoc = xmlDoc(fileFullName);
             XmlNode parentNode = GetNode(xDoc, parentName);
             if (parentNode == null) return false;
             if (parentNode.Name == xDoc.DocumentElement.Name)
             {
                 XmlNode newNode = xDoc.CreateNode(XmlNodeType.Element, xDoc.DocumentElement.ChildNodes[].Name, null);
                 AppendChild(xDoc, newNode, paras);
                 xDoc.DocumentElement.AppendChild(newNode);
             }
             else
             {
                 AddEveryNode(xDoc, parentNode, paras);
             }
             xDoc.Save(fileFullName);
             return true;
         }
         #endregion

         #region AddAttribute
         /// <summary>
         /// 添加节点属性
         /// </summary>
         /// <param name="xDoc">XmlDocument对象</param>
         /// <param name="node">节点对象</param>
         /// <param name="namespaceOfPrefix">该节点的命名空间URI</param>
         /// <param name="attributeName">新属性名称</param>
         /// <param name="attributeValue">属性值</param>
         public static void AddAttribute(XmlDocument xDoc, XmlNode node, string namespaceOfPrefix, string attributeName, string attributeValue)
         {
             string ns = namespaceOfPrefix == null ? null : node.GetNamespaceOfPrefix(namespaceOfPrefix);
             XmlNode xn = xDoc.CreateNode(XmlNodeType.Attribute, attributeName, ns == "" ? null : ns);
             xn.Value = attributeValue;
             node.Attributes.SetNamedItem(xn);
         }
         /// <summary>
         /// 添加节点属性
         /// </summary>
         /// <param name="xDoc">XmlDocument对象</param>
         /// <param name="node">节点对象</param>
         /// <param name="namespaceOfPrefix">该节点的命名空间URI</param>
         /// <param name="attps">节点属性参数</param>
         public static void AddAttribute(XmlDocument xDoc, XmlNode node, string namespaceOfPrefix, params AttributeParameter[] attps)
         {
             string ns = namespaceOfPrefix == null ? null : node.GetNamespaceOfPrefix(namespaceOfPrefix);
             foreach (AttributeParameter attp in attps)
             {
                 XmlNode xn = xDoc.CreateNode(XmlNodeType.Attribute, attp.Name, ns == "" ? null : ns);
                 xn.Value = attp.Value;
                 node.Attributes.SetNamedItem(xn);
             }
         }
         /// <summary>
         /// 添加节点属性
         /// </summary>
         /// <param name="fileFullName">文件名称，包括完整路径</param>
         /// <param name="node">节点对象</param>
         /// <param name="namespaceOfPrefix">该节点的命名空间URI</param>
         /// <param name="attributeName">新属性名称</param>
         /// <param name="attributeValue">属性值</param>
         public static void AddAttribute(string fileFullName, XmlNode node, string namespaceOfPrefix, string attributeName, string attributeValue)
         {
             XmlDocument xDoc = xmlDoc(fileFullName);
             AddAttribute(xDoc, node, namespaceOfPrefix, attributeName, attributeValue);
             xDoc.Save(fileFullName);
         }
         /// <summary>
         /// 添加节点属性
         /// </summary>
         /// <param name="fileFullName">文件名称，包括完整路径</param>
         /// <param name="node">节点对象</param>
         /// <param name="namespaceOfPrefix">该节点的命名空间URI</param>
         /// <param name="attps">节点属性参数</param>
         public static void AddAttribute(string fileFullName, XmlNode node, string namespaceOfPrefix, params AttributeParameter[] attps)
         {
             XmlDocument xDoc = xmlDoc(fileFullName);
             AddAttribute(xDoc, node, namespaceOfPrefix, attps);
             xDoc.Save(fileFullName);
         }
         /// <summary>
         /// 添加节点属性
         /// </summary>
         /// <param name="xDoc">XmlDocument对象</param>
         /// <param name="nodeName">节点名称</param>
         /// <param name="namespaceOfPrefix">该节点的命名空间URI</param>
         /// <param name="attributeName">新属性名称</param>
         /// <param name="attributeValue">属性值</param>
         public static void AddAttribute(XmlDocument xDoc, string nodeName, string namespaceOfPrefix, string attributeName, string attributeValue)
         {
             XmlNodeList xlst = xDoc.DocumentElement.ChildNodes;
             for (int i = ; i < xlst.Count; i++)
             {
                 XmlNode node = GetNode(xlst[i], nodeName);
                 if (node == null) return;
                 string ns = namespaceOfPrefix == null ? null : node.GetNamespaceOfPrefix(namespaceOfPrefix);
                 XmlNode xn = xDoc.CreateNode(XmlNodeType.Attribute, attributeName, ns == "" ? null : ns);
                 xn.Value = attributeValue;
                 node.Attributes.SetNamedItem(xn);
             }
         }
         /// <summary>
         /// 添加节点属性
         /// </summary>
         /// <param name="xDoc">XmlDocument对象</param>
         /// <param name="nodeName">节点名称</param>
         /// <param name="namespaceOfPrefix">该节点的命名空间URI</param>
         /// <param name="attps">节点属性参数</param>
         public static void AddAttribute(XmlDocument xDoc, string nodeName, string namespaceOfPrefix, params AttributeParameter[] attps)
         {
             XmlNodeList xlst = xDoc.DocumentElement.ChildNodes;
             for (int i = ; i < xlst.Count; i++)
             {
                 XmlNode node = GetNode(xlst[i], nodeName);
                 if (node == null) return;
                 string ns = namespaceOfPrefix == null ? null : node.GetNamespaceOfPrefix(namespaceOfPrefix);
                 foreach (AttributeParameter attp in attps)
                 {
                     XmlNode xn = xDoc.CreateNode(XmlNodeType.Attribute, attp.Name, ns == "" ? null : ns);
                     xn.Value = attp.Value;
                     node.Attributes.SetNamedItem(xn);
                 }
             }
         }
         /// <summary>
         /// 添加节点属性
         /// </summary>
         /// <param name="fileFullName">文件名称，包括完整路径</param>
         /// <param name="nodeName">节点名称</param>
         /// <param name="namespaceOfPrefix">该节点的命名空间URI</param>
         /// <param name="attributeName">新属性名称</param>
         /// <param name="attributeValue">属性值</param>
         public static void AddAttribute(string fileFullName, string nodeName, string namespaceOfPrefix, string attributeName, string attributeValue)
         {
             XmlDocument xDoc = xmlDoc(fileFullName);
             XmlNodeList xlst = xDoc.DocumentElement.ChildNodes;
             for (int i = ; i < xlst.Count; i++)
             {
                 XmlNode node = GetNode(xlst[i], nodeName);
                 if (node == null) break;
                 AddAttribute(xDoc, node, namespaceOfPrefix, attributeName, attributeValue);
             }
             xDoc.Save(fileFullName);
         }
         /// <summary>
         /// 添加节点属性
         /// </summary>
         /// <param name="fileFullName">文件名称，包括完整路径</param>
         /// <param name="nodeName">节点名称</param>
         /// <param name="namespaceOfPrefix">该节点的命名空间URI</param>
         /// <param name="attps">节点属性参数</param>
         public static void AddAttribute(string fileFullName, string nodeName, string namespaceOfPrefix, params AttributeParameter[] attps)
         {
             XmlDocument xDoc = xmlDoc(fileFullName);
             XmlNodeList xlst = xDoc.DocumentElement.ChildNodes;
             for (int i = ; i < xlst.Count; i++)
             {
                 XmlNode node = GetNode(xlst[i], nodeName);
                 if (node == null) break;
                 AddAttribute(xDoc, node, namespaceOfPrefix, attps);
             }
             xDoc.Save(fileFullName);
         }
         #endregion

         #region GetNode
         /// <summary>
         /// 获取指定节点名称的节点对象
         /// </summary>
         /// <param name="fileFullName">文件名称，包括完整路径</param>
         /// <param name="nodeName">节点名称</param>
         /// <returns></returns>
         public static XmlNode GetNode(string fileFullName, string nodeName)
         {
             XmlDocument xDoc = xmlDoc(fileFullName);
             if (xDoc.DocumentElement.Name == nodeName) return (XmlNode)xDoc.DocumentElement;
             XmlNodeList nlst = xDoc.DocumentElement.ChildNodes;
             foreach (XmlNode xns in nlst)  // 遍历所有子节点
             {
                 if (xns.Name.ToLower() == nodeName.ToLower()) return xns;
                 else
                 {
                     XmlNode xn = GetNode(xns, nodeName);
                     if (xn != null) return xn;  /// V1.0.0.3添加节点判断
                 }
             }
             return null;
         }
         /// <summary>
         /// 获取指定节点名称的节点对象
         /// </summary>
         /// <param name="node">节点对象</param>
         /// <param name="nodeName">节点名称</param>
         /// <returns></returns>
         public static XmlNode GetNode(XmlNode node, string nodeName)
         {
             foreach (XmlNode xn in node)
             {
                 if (xn.Name.ToLower() == nodeName.ToLower()) return xn;
                 else
                 {
                     XmlNode tmp = GetNode(xn, nodeName);
                     if (tmp != null) return tmp;
                 }
             }
             return null;
         }
         /// <summary>
         /// 获取指定节点名称的节点对象
         /// </summary>
         /// <param name="xDoc">XmlDocument对象</param>
         /// <param name="nodeName">节点名称</param>
         /// <returns></returns>
         public static XmlNode GetNode(XmlDocument xDoc, string nodeName)
         {
             if (xDoc.DocumentElement.Name == nodeName) return (XmlNode)xDoc.DocumentElement;
             XmlNodeList nlst = xDoc.DocumentElement.ChildNodes;
             foreach (XmlNode xns in nlst)  // 遍历所有子节点
             {
                 if (xns.Name.ToLower() == nodeName.ToLower()) return xns;
                 else
                 {
                     XmlNode xn = GetNode(xns, nodeName);
                     if (xn != null) return xn;   /// 添加节点判断, 避免只查询一个节点
                 }
             }
             return null;
         }
         /// <summary>
         /// 获取指定节点名称的节点对象
         /// </summary>
         /// <param name="xDoc">XmlDocument对象</param>
         /// <param name="Index">节点索引</param>
         /// <param name="nodeName">节点名称</param>
         public static XmlNode GetNode(XmlDocument xDoc, int Index, string nodeName)
         {
             XmlNodeList nlst = xDoc.DocumentElement.ChildNodes;
             if (nlst.Count <= Index) return null;
             if (nlst[Index].Name.ToLower() == nodeName.ToLower()) return (XmlNode)nlst[Index];
             foreach (XmlNode xn in nlst[Index])
             {
                 return GetNode(xn, nodeName);
             }
             return null;
         }
         /// <summary>
         /// 获取指定节点名称的节点对象
         /// </summary>
         /// <param name="fileFullName">文件名称，包括完整路径</param>
         /// <param name="Index">节点索引</param>
         /// <param name="nodeName">节点名称</param>
         public static XmlNode GetNode(string fileFullName, int Index, string nodeName)
         {
             XmlDocument xDoc = xmlDoc(fileFullName);
             XmlNodeList nlst = xDoc.DocumentElement.ChildNodes;
             if (nlst.Count <= Index) return null;
             if (nlst[Index].Name.ToLower() == nodeName.ToLower()) return (XmlNode)nlst[Index];
             foreach (XmlNode xn in nlst[Index])
             {
                 return GetNode(xn, nodeName);
             }
             return null;
         }
         /// <summary>
         /// 获取指定节点名称的节点对象
         /// </summary>
         /// <param name="node">节点对象</param>
         /// <param name="nodeName">节点名称</param>
         /// <param name="innerText">节点内容</param>
         public static XmlNode GetNode(XmlNode node, string nodeName, string innerText)
         {
             foreach (XmlNode xn in node)
             {
                 if (xn.Name.ToLower() == nodeName.ToLower() && xn.InnerText == innerText) return xn;
                 else
                 {
                     XmlNode tmp = GetNode(xn, nodeName, innerText);
                     if (tmp != null) return tmp;
                 }
             }
             return null;
         }
         /// <summary>
         /// 获取指定节点名称的节点对象
         /// </summary>
         /// <param name="xDoc">XmlDocument对象</param>
         /// <param name="nodeName">节点名称</param>
         /// <param name="innerText">节点内容</param>
         public static XmlNode GetNode(XmlDocument xDoc, string nodeName, string innerText)
         {
             XmlNodeList nlst = xDoc.DocumentElement.ChildNodes;
             foreach (XmlNode xns in nlst)  // 遍历所有子节点
             {
                 if (xns.Name.ToLower() == nodeName.ToLower() && xns.InnerText == innerText) return xns;
                 XmlNode tmp = GetNode(xns, nodeName, innerText);
                 if (tmp != null) return tmp;
             }
             return null;
         }
         /// <summary>
         /// 获取指定节点名称的节点对象
         /// </summary>
         /// <param name="xDoc">XmlDocument对象</param>
         /// <param name="xpar">XML参数</param>
         public static XmlNode GetNode(XmlDocument xDoc, XmlParameter xpar)
         {
             return GetNode(xDoc, xpar.Name, xpar.InnerText);
         }
         /// <summary>
         /// 获取指定节点名称的节点对象
         /// </summary>
         /// <param name="node">节点对象</param>
         /// <param name="xpar">XML参数</param>
         public static XmlNode GetNode(XmlNode node, XmlParameter xpar)
         {
             return GetNode(node, xpar.Name, node.InnerText);
         }
         #endregion

         #region UpdateNode
         /// <summary>
         /// 修改节点的内容
         /// </summary>
         /// <param name="node">修改的节点对象</param>
         /// <param name="para">XML参数对象</param>
         public static void UpdateNode(XmlNode node, XmlParameter para)
         {
             node.InnerText = para.InnerText;
             for (int i = ; i < para.Attributes.Length; i++)
             {
                 node.Attributes.Item(i).Value = para.Attributes[i].Value;
             }
         }
         /// <summary>
         /// 修改节点的内容
         /// </summary>
         /// <param name="node">父节点对象</param>
         /// <param name="childIndex">该节点的索引</param>
         /// <param name="nodeText">修改后的内容</param>
         public static void UpdateNode(XmlNode node, int childIndex, string nodeText)
         {
             node.ChildNodes[childIndex].InnerText = nodeText;
         }
         /// <summary>
         /// 修改节点的内容
         /// </summary>
         /// <param name="node">修改的节点对象</param>
         /// <param name="nodeText">修改后的内容</param>
         public static void UpdateNode(XmlNode node, string nodeText)
         {
             node.InnerText = nodeText;
         }
         /// <summary>
         /// 修改节点的内容
         /// </summary>
         /// <param name="xDoc">XMLDocument对象</param>
         /// <param name="para">XML参数对象</param>
         public static void UpdateNode(XmlDocument xDoc, int Index, XmlParameter para)
         {
             XmlNode node = GetNode(xDoc, Index, para.Name);
             UpdateNode(node, para);
         }
         /// <summary>
         /// 修改节点的内容
         /// </summary>
         /// <param name="xDoc">XMLDocument对象</param>
         /// <param name="nodeName">父节点名称</param>
         /// <param name="childIndex">该节点的索引</param>
         /// <param name="nodeText">修改后的内容</param>
         /// <param name="nodeValue">修改后的值，如果没有，那么该值为null</param>
         public static void UpdateNode(XmlDocument xDoc, int Index, string nodeName, int childIndex, string nodeText)
         {
             XmlNode node = GetNode(xDoc, Index, nodeName);
             UpdateNode(node, childIndex, nodeText);
         }
         /// <summary>
         /// 修改节点的内容
         /// </summary>
         /// <param name="xDoc">XMLDocument对象</param>
         /// <param name="nodeName">修改的节点名称</param>
         /// <param name="nodeText">修改后的内容</param>
         /// <param name="nodeValue">修改后的值，如果没有，那么该值为null</param>
         public static void UpdateNode(XmlDocument xDoc, int Index, string nodeName, string nodeText)
         {
             XmlNode node = GetNode(xDoc, Index, nodeName);
             UpdateNode(node, nodeText);
         }
         /// <summary>
         /// 修改节点的内容
         /// </summary>
         /// <param name="fileFullName">文件名称，包括完整路径</param>
         /// <param name="para">XML参数对象</param>
         public static void UpdateNode(string fileFullName, int Index, XmlParameter para)
         {
             XmlDocument xDoc = xmlDoc(fileFullName);
             UpdateNode(xDoc, Index, para);
             xDoc.Save(fileFullName);
         }
         /// <summary>
         /// 修改节点的内容
         /// </summary>
         /// <param name="fileFullName">文件名称，包括完整路径</param>
         /// <param name="nodeName">父节点名称</param>
         /// <param name="childIndex">该节点的索引</param>
         /// <param name="nodeText">修改后的内容</param>
         public static void UpdateNode(string fileFullName, int Index, string nodeName, int childIndex, string nodeText)
         {
             XmlDocument xDoc = xmlDoc(fileFullName);
             UpdateNode(xDoc, Index, nodeName, childIndex, nodeText);
             xDoc.Save(fileFullName);
         }
         /// <summary>
         /// 修改节点的内容
         /// </summary>
         /// <param name="fileFullName">文件名称，包括完整路径</param>
         /// <param name="nodeName">修改的节点名称</param>
         /// <param name="nodeText">修改后的内容</param>
         public static void UpdateNode(string fileFullName, int Index, string nodeName, string nodeText)
         {
             XmlDocument xDoc = xmlDoc(fileFullName);
             UpdateNode(xDoc, Index, nodeName, nodeText);
             xDoc.Save(fileFullName);
         }
         #endregion

         #region DeleteNode
         /// <summary>
         /// 删除节点
         /// </summary>
         /// <param name="xDoc">XmlDocument对象</param>
         /// <param name="Index">节点索引</param>
         public static void DeleteNode(XmlDocument xDoc, int Index)
         {
             XmlNodeList nlst = xDoc.DocumentElement.ChildNodes;
             nlst[Index].ParentNode.RemoveChild(nlst[Index]);
         }
         /// <summary>
         /// 删除节点
         /// </summary>
         /// <param name="fileFullName">文件名称，包括完整路径</param>
         /// <param name="Index">节点索引</param>
         public static void DeleteNode(string fileFullName, int Index)
         {
             XmlDocument xDoc = xmlDoc(fileFullName);
             DeleteNode(xDoc, Index);
             xDoc.Save(fileFullName);
         }
         /// <summary>
         /// 删除节点
         /// </summary>
         /// <param name="xDoc">XmlDocument对象</param>
         /// <param name="xns">需要删除的节点对象</param>
         public static void DeleteNode(XmlDocument xDoc, params XmlNode[] xns)
         {
             foreach (XmlNode xnl in xns)
             {
                 foreach (XmlNode xn in xDoc.DocumentElement.ChildNodes)
                 {
                     if (xnl.Equals(xn))
                     {
                         xn.ParentNode.RemoveChild(xn);
                         break;
                     }
                 }
             }
         }
         /// <summary>
         /// 删除节点
         /// </summary>
         /// <param name="fileFullName">文件名称，包括完整路径</param>
         /// <param name="xns">需要删除的节点对象</param>
         public static void DeleteNode(string fileFullName, params XmlNode[] xns)
         {
             XmlDocument xDoc = xmlDoc(fileFullName);
             DeleteNode(xDoc, xns);
             xDoc.Save(fileFullName);
         }
         /// <summary>
         /// 删除节点
         /// </summary>
         /// <param name="xDoc">XmlDocument对象</param>
         /// <param name="nodeName">节点名称</param>
         /// <param name="nodeText">节点内容</param>
         public static void DeleteNode(XmlDocument xDoc, string nodeName, string nodeText)
         {
             foreach (XmlNode xn in xDoc.DocumentElement.ChildNodes)
             {
                 if (xn.Name == nodeName)
                 {
                     if (xn.InnerText == nodeText)
                     {
                         xn.ParentNode.RemoveChild(xn);
                         return;
                     }
                 }
                 else
                 {
                     XmlNode node = GetNode(xn, nodeName);
                     if (node != null && node.InnerText == nodeText)
                     {
                         node.ParentNode.ParentNode.RemoveChild(node.ParentNode);
                         return;
                     }
                 }
             }
         }
         /// <summary>
         /// 删除节点
         /// </summary>
         /// <param name="fileFullName">文件名称，包括完整路径</param>
         /// <param name="nodeName">节点名称</param>
         /// <param name="nodeText">节点内容</param>
         public static void DeleteNode(string fileFullName, string nodeName, string nodeText)
         {
             XmlDocument xDoc = xmlDoc(fileFullName);
             DeleteNode(xDoc, nodeName, nodeText);
             xDoc.Save(fileFullName);
         }
         #endregion

         #region SetAttribute
         /// <summary>
         /// 修改属性值
         /// </summary>
         /// <param name="node">节点对象</param>
         /// <param name="attps">属性参数</param>
         public static void SetAttribute(XmlNode node, params AttributeParameter[] attps)
         {
             XmlElement xe = (XmlElement)node;
             foreach (AttributeParameter attp in attps)
             {
                 xe.SetAttribute(attp.Name, attp.Value);
             }
         }
         /// <summary>
         /// 修改属性值
         /// </summary>
         /// <param name="node">节点对象</param>
         /// <param name="attributeName">属性名称</param>
         /// <param name="attributeValue">属性值</param>
         public static void SetAttribute(XmlNode node, string attributeName, string attributeValue)
         {
             XmlElement xe = (XmlElement)node;
             xe.SetAttribute(attributeName, attributeValue);
         }
         /// <summary>
         /// 修改属性值
         /// </summary>
         /// <param name="elem">元素对象</param>
         /// <param name="attps">属性参数</param>
         public static void SetAttribute(XmlElement elem, params AttributeParameter[] attps)
         {
             foreach (AttributeParameter attp in attps)
             {
                 elem.SetAttribute(attp.Name, attp.Value);
             }
         }
         /// <summary>
         /// 修改属性值
         /// </summary>
         /// <param name="elem">元素对象</param>
         /// <param name="attributeName">属性名称</param>
         /// <param name="attributeValue">属性值</param>
         public static void SetAttribute(XmlElement elem, string attributeName, string attributeValue)
         {
             elem.SetAttribute(attributeName, attributeValue);
         }
         /// <summary>
         /// 修改属性值
         /// </summary>
         /// <param name="xDoc">XmlDocument对象</param>
         /// <param name="xpara">XML参数</param>
         /// <param name="attps">属性参数</param>
         public static void SetAttribute(XmlDocument xDoc, XmlParameter xpara, params AttributeParameter[] attps)
         {
             XmlElement xe = (XmlElement)GetNode(xDoc, xpara);
             if (xe == null) return;
             SetAttribute(xe, attps);
         }
         /// <summary>
         /// 修改属性值
         /// </summary>
         /// <param name="xDoc">XmlDocument对象</param>
         /// <param name="xpara">XML参数</param>
         /// <param name="newValue">新属性值</param>
         public static void SetAttribute(XmlDocument xDoc, XmlParameter xpara, string attributeName, string newValue)
         {
             XmlElement xe = (XmlElement)GetNode(xDoc, xpara);
             if (xe == null) return;
             SetAttribute(xe, attributeName, newValue);
         }
         /// <summary>
         /// 修改属性值
         /// </summary>
         /// <param name="fileFullName">文件名称，包括完整路径</param>
         /// <param name="xpara">XML参数</param>
         /// <param name="newValue">新属性值</param>
         public static void SetAttribute(string fileFullName, XmlParameter xpara, string attributeName, string newValue)
         {
             XmlDocument xDoc = xmlDoc(fileFullName);
             SetAttribute(xDoc, xpara, attributeName, newValue);
             xDoc.Save(fileFullName);
         }
         /// <summary>
         /// 修改属性值
         /// </summary>
         /// <param name="fileFullName">文件名称，包括完整路径</param>
         /// <param name="xpara">XML参数</param>
         /// <param name="attps">属性参数</param>
         public static void SetAttribute(string fileFullName, XmlParameter xpara, params AttributeParameter[] attps)
         {
             XmlDocument xDoc = xmlDoc(fileFullName);
             SetAttribute(xDoc, xpara, attps);
             xDoc.Save(fileFullName);
         }
         #endregion
     }

     public sealed class XmlParameter
     {
         private string name;
         private string innerText;
         private string namespaceOfPrefix;
         private AttributeParameter[] attributes;

         public XmlParameter()
         {
             //
             // TODO: Add constructor logic here
             //
             this.namespaceOfPrefix = null;
         }

         public XmlParameter(string name, params AttributeParameter[] attParas)
         {
             this.name = name;
             this.namespaceOfPrefix = null;
             this.attributes = attParas;
         }

         public XmlParameter(string name, string innerText, params AttributeParameter[] attParas)
         {
             this.name = name;
             this.innerText = innerText;
             this.namespaceOfPrefix = null;
             this.attributes = attParas;
         }

         public XmlParameter(string name, string innerText, string namespaceOfPrefix, params AttributeParameter[] attParas)
         {
             this.name = name;
             this.innerText = innerText;
             this.namespaceOfPrefix = namespaceOfPrefix;
             this.attributes = attParas;
         }

         public string Name
         {
             get { return this.name; }
             set { this.name = value; }
         }

         public string InnerText
         {
             get { return this.innerText; }
             set { this.innerText = value; }
         }

         public string NamespaceOfPrefix
         {
             get { return this.namespaceOfPrefix; }
             set { this.namespaceOfPrefix = value; }
         }

         public AttributeParameter[] Attributes
         {
             get { return this.attributes; }
             set { this.attributes = value; }
         }
     }

     public sealed class AttributeParameter
     {
         private string name;
         private string value;

         public AttributeParameter()
         {
             //
             // TODO: Add constructor logic here
             //
         }
         public AttributeParameter(string attributeName, string attributeValue)
         {
             this.name = attributeName;
             this.value = attributeValue;
         }
         public string Name
         {
             get { return this.name; }
             set { this.name = value; }
         }
         public string Value
         {
             get { return this.value; }
             set { this.value = value; }
         }
     }

 }