XML 文檔解析操做

sing 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;

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

加載XML文件，建立操做對象#region 加載XML文件，建立操做對象
/**//// <summary>
/// 加載XML文件，建立操做對象
/// </summary>
public void OpenXML()
{
try
{
if (!string.IsNullOrEmpty(FilePath))
{
xmlDoc.Load(filePath);
}
else
{
FilePath = string.Format(@"D:\\XMLExample.xml"); //默認路徑
xmlDoc.Load(filePath);
}
}
catch (Exception ex)
{
ErrorMess = ex;
}
}
#endregion

建立Xml 文檔#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

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

獲取XML節點值#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

更新節點屬性和子節點InnerText 值#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

保存XML文件#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}