xml 操作类【转】

using System;
using System.Data;
using System.Configuration;
using System.Linq;
using System.Xml.Linq;
using System.Xml;
public class XMLHelper
{
    public XMLHelper()
    {
        //
        // TODO: Add constructor logic here
        //
    }

    #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[0].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[0].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[0].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[0].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 = 0; 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 = 0; 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 = 0; 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 = 0; 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 = 0; 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; }
    }
}

使用例子：

XmlParameter[] paras ={
  new XmlParameter("name","首页对话框"),
  new XmlParameter("msg")
};
XMLHelper.CreateXMLFile("D:\\Err.xml", new XmlParameter("Errors", new AttributeParameter("page", "10")), "Err", paras);
//创建xml文档

XmlParameter[] paras ={
   new XmlParameter("en","username"),
   new XmlParameter("cn","用户名")
};
XMLHelper.AddNewNode("D:\\Err.xml", "msg", paras); //添加节点

XmlParameter[] paras =
{
   new XmlParameter("name", "test", new AttributeParameter("ID", "02")),
   new XmlParameter("msg")
 };
XMLHelper.AddNewNode("D:\\Err.xml", "Errors", paras);

//XMLHelper.UpdateNode("D:\\Err.xml", 0, "name", 0, "ziyou");
/*XmlDocument xDoc = XMLHelper.xmlDoc("D:\\Err.xml");
//XMLHelper.UpdateNode(XMLHelper.GetNode(xDoc, "en", "test"), "changeText");
xDoc.Save("D:\\Err.xml");*/
//修改节点内容
            
AttributeParameter[] attps =
{
   new AttributeParameter("ID","123"),
   new AttributeParameter("df","test")
};
XMLHelper.AddAttribute("D:\\Err.xml", "en", null, attps);
//添加节点属性

XMLHelper.DeleteNode("D:\\Err.xml", 1);
XMLHelper.DeleteNode("D:\\Err.xml", "name", "test");

XMLHelper.SetAttribute("D:\\Err.xml", new XmlParameter("name", "test"), new AttributeParameter("ID", "41524"));