C#操作xml文檔的通用類

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Xml;
using System.Collections;
using System.IO;
using Corporation.DAL;

/// <summary>
/// XML操作：
/// 參照手冊http://www.w3school.com.cn/xpath/xpath_operators.asp
/// </summary>
public class XMLHealper
{

#region 構造函數
public XMLHealper()
{
    FilePath = XMLPath.GetXMLPath();
    OpenXML();
}
#endregion

#region 對象定義

private XmlDocument xmlDoc = new XmlDocument();
XmlNode xmlnode;
XmlElement xmlelem;

#endregion

#region 屬性定義

private string errorMess;
public string ErrorMess
{
    get { return errorMess; }
    set { errorMess = value; }
}

private string filePath;
public string FilePath
{
    set { filePath = value; }
    get { return filePath; }
}

#endregion

#region 創建XML操作對象
/// <summary>
/// 創建XML操作對象
/// </summary>
public void OpenXML()
{
    try
    {
        if (!string.IsNullOrEmpty(FilePath))
        {
            xmlDoc.Load(filePath);
        }
        else
        {
            FilePath = string.Format(@"E:\log4net.xml"); //默認路徑
            xmlDoc.Load(filePath);
        }
    }
    catch (Exception ex)
    {
        ErrorMess = ex;
    }
}
#endregion

#region 創建Xml 文檔
/// <summary>
/// 創建一個帶有根節點的Xml 文件
/// </summary>
/// <param name="FileName">Xml 文件名稱</param>
/// <param name="rootName">根節點名稱</param>
/// <param name="Encode">編碼方式:gb2312，UTF-8 等常見的</param>
/// <param name="DirPath">保存的目錄路徑</param>
/// <returns></returns>
public bool CreatexmlDocument(string FileName, string rootName, string Encode)
{
    try
    {
        XmlDeclaration xmldecl;
        xmldecl = xmlDoc.CreateXmlDeclaration("1.0", Encode, null);
        xmlDoc.AppendChild(xmldecl);
        xmlelem = xmlDoc.CreateElement("", rootName, "");
        xmlDoc.AppendChild(xmlelem);
        xmlDoc.Save(FileName);
        return true;
    }
    catch (Exception e)
    {
        return false;
    }
}
#endregion

//獲取值

#region 得到表
/// <summary>
/// 得到表
/// </summary>
/// <returns></returns>
public DataView GetData()
{
    xmlDoc = new XmlDocument();
    DataSet ds = new DataSet();
    StringReader read = new StringReader(xmlDoc.SelectSingleNode(FilePath).OuterXml);
    ds.ReadXml(read);
    return ds.Tables[0].DefaultView;
}
#endregion

#region 讀取指定節點的指定屬性值
/// <summary>
/// 功能:
/// 讀取指定節點的指定屬性值
/// </summary>
/// <param name="strNode">節點名稱(相對路徑：//+節點名稱)</param>
/// <param name="strAttribute">此節點的屬性</param>
/// <returns></returns>
public string GetXmlNodeValue(string strNode, string strAttribute)
{
    string strReturn = "";
    try
    {
        //根據指定路徑獲取節點
        XmlNode xmlNode = xmlDoc.SelectSingleNode(strNode);
        //獲取節點的屬性，并循環取出需要的屬性值
        XmlAttributeCollection xmlAttr = xmlNode.Attributes;

        for (int i = 0; i < xmlAttr.Count; i++)
        {
            if (xmlAttr.Item(i).Name == strAttribute)
            {
                strReturn = xmlAttr.Item(i).Value;
            }
        }
    }
    catch (XmlException xmle)
    {
        throw xmle;
    }
    return strReturn;
}
#endregion

#region 讀取指定節點的值
/// <summary>
/// 功能:
/// 讀取指定節點的值
/// </summary>
/// <param name="strNode">節點名稱</param>
/// <returns></returns>
public string GetXmlNodeValue(string strNode)
{
    string strReturn = String.Empty;
    try
    {
        //根據路徑獲取節點
        XmlNode xmlNode = xmlDoc.SelectSingleNode(strNode);
        strReturn = xmlNode.InnerText;
    }
    catch (XmlException xmle)
    {
        System.Console.WriteLine(xmle.Message);
    }
    return strReturn;
}
#endregion

#region 獲取XML文件的根元素
/// <summary>
/// 獲取XML文件的根元素
/// </summary>
public XmlNode GetXmlRoot()
{
    return xmlDoc.DocumentElement;
}
#endregion

#region 獲取XML節點值
/// <summary>
/// 獲取XML節點值
/// </summary>
/// <param name="nodeName"></param>
/// <returns></returns>
public string GetNodeValue(string nodeName)
{
    xmlDoc = new XmlDocument();
    xmlDoc.Load(FilePath);

    XmlNodeList xnl = xmlDoc.ChildNodes;
    foreach (XmlNode xnf in xnl)
    {
        XmlElement xe = (XmlElement)xnf;
        XmlNodeList xnf1 = xe.ChildNodes;
        foreach (XmlNode xn2 in xnf1)
        {
            if (xn2.InnerText == nodeName)
            {
                XmlElement xe2 = (XmlElement)xn2;
                return xe2.GetAttribute("value");
            }
        }
    }
    return null;
}
#endregion

//添加或插入

#region 設置節點值
/// <summary>
/// 功能:
/// 設置節點值
/// </summary>
/// <param name="strNode">節點的名稱</param>
/// <param name="newValue">節點值</param>
public void SetXmlNodeValue(string xmlNodePath, string xmlNodeValue)
{
    try
    {
        //根據指定路徑獲取節點
        XmlNode xmlNode = xmlDoc.SelectSingleNode(xmlNodePath);
        //設置節點值
        xmlNode.InnerText = xmlNodeValue;
    }
    catch (XmlException xmle)
    {
        throw xmle;
    }
}
#endregion

#region 添加父節點

/// <summary>
/// 在根節點下添加父節點
/// </summary>
public void AddParentNode(string parentNode)
{
    XmlNode root = GetXmlRoot();
    XmlNode parentXmlNode = xmlDoc.CreateElement(parentNode);

    root.AppendChild(parentXmlNode);
}
#endregion

#region 向一個已經存在的父節點中插入一個子節點
/// <summary>
/// 向一個已經存在的父節點中插入一個子節點
/// </summary>
public void AddChildNode(string parentNodePath, string childNodePath)
{
    XmlNode parentXmlNode = xmlDoc.SelectSingleNode(parentNodePath);
    XmlNode childXmlNode = xmlDoc.CreateElement(childNodePath);

    parentXmlNode.AppendChild(childXmlNode);
}
#endregion

#region 向一個節點添加屬性
/// <summary>
/// 向一個節點添加屬性
/// </summary>
public void AddAttribute(string NodePath, string NodeAttribute)
{
    XmlAttribute nodeAttribute = xmlDoc.CreateAttribute(NodeAttribute);
    XmlNode nodePath = xmlDoc.SelectSingleNode(NodePath);
    nodePath.Attributes.Append(nodeAttribute);
}
#endregion

#region 插入一個節點和它的若干子節點
/// <summary>
/// 插入一個節點和它的若干子節點
/// </summary>
/// <param name="NewNodeName">插入的節點名稱</param>
/// <param name="HasAttributes">此節點是否具有屬性，True 為有，False 為無</param>
/// <param name="fatherNode">此插入節點的父節點</param>
/// <param name="htAtt">此節點的屬性，Key 為屬性名，Value 為屬性值</param>
/// <param name="htSubNode"> 子節點的屬性， Key 為Name,Value 為InnerText</param>
/// <returns>返回真為更新成功，否則失敗</returns>
public bool InsertNode(string NewNodeName, bool HasAttributes, string fatherNode, Hashtable htAtt, Hashtable htSubNode)
{
    try
    {
        xmlDoc.Load(FilePath);
        XmlNode root = xmlDoc.SelectSingleNode(fatherNode);
        xmlelem = xmlDoc.CreateElement(NewNodeName);
        if (htAtt != null && HasAttributes)//若此節點有屬性，則先添加屬性
        {
            SetAttributes(xmlelem, htAtt);
            AddNodes(xmlelem.Name, xmlDoc, xmlelem, htSubNode);//添加完此節點屬性后，再添加它的子節點和它們的InnerText
        }
        else
        {
            AddNodes(xmlelem.Name, xmlDoc, xmlelem, htSubNode);//若此節點無屬性，那么直接添加它的子節點
        }
        root.AppendChild(xmlelem);
        xmlDoc.Save(FilePath);
        return true;
    }
    catch (Exception e)
    {
        throw new Exception(e.Message);
    }
}
#endregion

#region 設置節點屬性
/// <summary>
/// 設置節點屬性
/// </summary>
/// <param name="xe">節點所處的Element</param>
/// <param name="htAttribute">節點屬性，Key 代表屬性名稱，Value 代表屬性值</param>
public void SetAttributes(XmlElement xe, Hashtable htAttribute)
{
    foreach (DictionaryEntry de in htAttribute)
    {
        xe.SetAttribute(de.Key.ToString(), de.Value.ToString());
    }
}
#endregion

#region 增加子節點到根節點下
/// <summary>
/// 增加子節點到根節點下
/// </summary>
/// <param name="rootNode">上級節點名稱</param>
/// <param name="xmlDoc">Xml 文檔</param>
/// <param name="rootXe">父根節點所屬的Element</param>
/// <param name="SubNodes">子節點屬性，Key 為Name 值，Value 為InnerText 值</param>
public void AddNodes(string rootNode, XmlDocument xmlDoc, XmlElement rootXe, Hashtable SubNodes)
{
    foreach (DictionaryEntry de in SubNodes)
    {
        xmlnode = xmlDoc.SelectSingleNode(rootNode);
        XmlElement subNode = xmlDoc.CreateElement(de.Key.ToString());
        subNode.InnerText = de.Value.ToString();
        rootXe.AppendChild(subNode);
    }
}
#endregion

//更新

#region 設置節點的屬性值
/// <summary>
/// 功能:
/// 設置節點的屬性值
/// </summary>
/// <param name="xmlNodePath">節點名稱</param>
/// <param name="xmlNodeAttribute">屬性名稱</param>
/// <param name="xmlNodeAttributeValue">屬性值</param>
public void SetXmlNodeValue(string xmlNodePath, string xmlNodeAttribute, string xmlNodeAttributeValue)
{
    try
    {
        //根據指定路徑獲取節點
        XmlNode xmlNode = xmlDoc.SelectSingleNode(xmlNodePath);

        //獲取節點的屬性，并循環取出需要的屬性值
        XmlAttributeCollection xmlAttr = xmlNode.Attributes;
        for (int i = 0; i < xmlAttr.Count; i++)
        {
            if (xmlAttr.Item(i).Name == xmlNodeAttribute)
            {
                xmlAttr.Item(i).Value = xmlNodeAttributeValue;
                break;
            }
        }
    }
    catch (XmlException xmle)
    {
        throw xmle;
    }
}

#endregion

#region 更新節點
/// <summary>
/// 更新節點
/// </summary>
/// <param name="fatherNode">需要更新節點的上級節點</param>
/// <param name="htAtt">需要更新的屬性表，Key 代表需要更新的屬性，Value 代表更新后的值</param>
/// <param name="htSubNode">需要更新的子節點的屬性表，Key 代表需要更新的子節點名字Name,Value 代表更新后的值InnerText</param>
/// <returns>返回真為更新成功，否則失敗</returns>
public bool UpdateNode(string fatherNode, Hashtable htAtt, Hashtable htSubNode)
{
    try
    {
        xmlDoc = new XmlDocument();
        xmlDoc.Load(FilePath);
        XmlNodeList root = xmlDoc.SelectSingleNode(fatherNode).ChildNodes;
        UpdateNodes(root, htAtt, htSubNode);
        xmlDoc.Save(FilePath);
        return true;
    }
    catch (Exception e)
    {
        throw new Exception(e.Message);
    }
}
#endregion

#region 更新節點屬性和子節點InnerText 值
/// <summary>
/// 更新節點屬性和子節點InnerText 值
/// </summary>
/// <param name="root">根節點名字</param>
/// <param name="htAtt">需要更改的屬性名稱和值</param>
/// <param name="htSubNode">需要更改InnerText 的子節點名字和值</param>
public void UpdateNodes(XmlNodeList root, Hashtable htAtt, Hashtable htSubNode)
{
    foreach (XmlNode xn in root)
    {
        xmlelem = (XmlElement)xn;
        if (xmlelem.HasAttributes)//如果節點如屬性，則先更改它的屬性
        {
            foreach (DictionaryEntry de in htAtt)//遍歷屬性哈希表
            {
                if (xmlelem.HasAttribute(de.Key.ToString()))//如果節點有需要更改的屬性
                {
                    xmlelem.SetAttribute(de.Key.ToString(), de.Value.ToString());//則把哈希表中相應的值Value 賦給此屬性Key
                }
            }
        }
        if (xmlelem.HasChildNodes)//如果有子節點，則修改其子節點的InnerText
        {
            XmlNodeList xnl = xmlelem.ChildNodes;
            foreach (XmlNode xn1 in xnl)
            {
                XmlElement xe = (XmlElement)xn1;
                foreach (DictionaryEntry de in htSubNode)
                {
                    if (xe.Name == de.Key.ToString())//htSubNode 中的key 存儲了需要更改的節點名稱，
                    {
                        xe.InnerText = de.Value.ToString();//htSubNode中的Value存儲了Key 節點更新后的數據
                    }
                }
            }
        }
    }
}
#endregion

//刪除

#region 刪除一個節點的屬性
/// <summary>
/// 刪除一個節點的屬性
/// </summary>
public void DeleteAttribute(string NodePath, string NodeAttribute, string NodeAttributeValue)
{
    XmlNodeList nodePath = xmlDoc.SelectSingleNode(NodePath).ChildNodes;

    foreach (XmlNode xn in nodePath)
    {
        XmlElement xe = (XmlElement)xn;

        if (xe.GetAttribute(NodeAttribute) == NodeAttributeValue)
        {
            xe.RemoveAttribute(NodeAttribute);//刪除屬性
        }
    }
}

#endregion

#region 刪除一個節點
/// <summary>
/// 刪除一個節點
/// </summary>
public void DeleteXmlNode(string tempXmlNode)
{
    XmlNode xmlNodePath = xmlDoc.SelectSingleNode(tempXmlNode);
    xmlNodePath.ParentNode.RemoveChild(xmlNodePath);
}

#endregion

#region 刪除指定節點下的子節點
/// <summary>
/// 刪除指定節點下的子節點
/// </summary>
/// <param name="fatherNode">制定節點</param>
/// <returns>返回真為更新成功，否則失敗</returns>
public bool DeleteNodes(string fatherNode)
{
    try
    {
        xmlDoc = new XmlDocument();
        xmlDoc.Load(FilePath);
        xmlnode = xmlDoc.SelectSingleNode(fatherNode);
        xmlnode.RemoveAll();
        xmlDoc.Save(FilePath);
        return true;
    }
    catch (XmlException xe)
    {
        throw new XmlException(xe.Message);
    }
}
#endregion

//內部函數與保存

#region 私有函數

private string functionReturn(XmlNodeList xmlList, int i, string nodeName)
{
    string node = xmlList[i].ToString();
    string rusultNode = "";
    for (int j = 0; j < i; j++)
    {
        if (node == nodeName)
        {
            rusultNode = node.ToString();
        }
        else
        {
            if (xmlList[j].HasChildNodes)
            {
                functionReturn(xmlList, j, nodeName);
            }
            else
            {
                break;
            }
        }
    }
    return rusultNode;


}

#endregion

#region 保存XML文件
/// <summary>
/// 功能: 
/// 保存XML文件
/// 
/// </summary>
public void SavexmlDocument()
{
    try
    {
        xmlDoc.Save(FilePath);
    }
    catch (XmlException xmle)
    {
        throw xmle;
    }
}
/// <summary>
/// 功能: 保存XML文件
/// </summary>
/// <param name="tempXMLFilePath"></param>
public void SavexmlDocument(string tempXMLFilePath)
{
    try
    {
        xmlDoc.Save(tempXMLFilePath);
    }
    catch (XmlException xmle)
    {
        throw xmle;
    }
}
#endregion

}
</pre>