xml操作类,封装了常用的对XML文件的操作功能....

using System;
using System.Xml;
using System.Xml.XPath;
using System.Xml.Xsl;
using System.Web;
using System.Collections;
using System.Collections.Generic;
using System.Text;

namespace WWFCommonClassLib
{
/// <summary>
/// 该类主要封装对XML的常用操作，需要XPath表达式来获得相应节点
/// GeneralXu 07-04-19
/// </summary>
public class XmlEditClass
{
#region 变量
//xml文件所在路径类型
public enum enumXmlPathType
{
AbsolutePath,VirtualPath //绝对路径，虚拟路径
}
private string xmlFilePath ;
private enumXmlPathType xmlFilePathType ;
private XmlDocument xmlDoc = new XmlDocument() ;
#endregion

#region 属性
// 文件路径
public string XmlFilePath
{
get{return this.xmlFilePath;}
set{xmlFilePath = value ;}
}
// 文件路径类型
public enumXmlPathType XmlFilePathType
{
set{xmlFilePathType = value ;}
}
#endregion

#region 构造函数
public XmlEditClass(string tempXmlFilePath)
{
//在此添加构造函数逻辑
this.xmlFilePathType = enumXmlPathType.VirtualPath ;
this.xmlFilePath = tempXmlFilePath ;
GetXmlDocument() ;
}

public XmlEditClass(string tempXmlFilePath, enumXmlPathType tempXmlFilePathType)
{
//在此添加构造函数逻辑
this.xmlFilePathType = tempXmlFilePathType ;
this.xmlFilePath = tempXmlFilePath ;
GetXmlDocument() ;
}
#endregion

#region 获取XmlDocument实体类
private XmlDocument GetXmlDocument()
{
XmlDocument xmlDoc=null;
if( this.xmlFilePathType == enumXmlPathType.AbsolutePath )
{
xmlDoc = GetXmlDocumentFromFile( xmlFilePath ) ;
}
else if( this.xmlFilePathType == enumXmlPathType.VirtualPath )
{
xmlDoc = GetXmlDocumentFromFile(HttpContext.Current.Server.MapPath(xmlFilePath)) ;
}
return xmlDoc;
}

private XmlDocument GetXmlDocumentFromFile(string tempXmlFilePath)
{
string xmlFileFullPath = tempXmlFilePath ;
xmlDoc.Load(xmlFileFullPath) ;
//定义事件处理
xmlDoc.NodeChanged += new XmlNodeChangedEventHandler(this.nodeUpdateEvent);
xmlDoc.NodeInserted += new XmlNodeChangedEventHandler(this.nodeInsertEvent);
xmlDoc.NodeRemoved += new XmlNodeChangedEventHandler(this.nodeDeleteEvent);
return xmlDoc ;
}

#endregion
#region 读取指定接点的属性
public string GetXmlNodeAttributeValue(string strNode,string strAttribute)
{
string strReturn = "";
try
{
//根据指定路径获取节点
XmlNode xmlNode = xmlDoc.SelectSingleNode(strNode) ;
if (!(xmlNode==null))
{
//获取节点的属性，并循环取出需要的属性值
XmlAttributeCollection xmlAttr = xmlNode.Attributes ;
for(int i=0 ;i<xmlAttr.Count;i++)
{
if (xmlAttr.Item(i).Name == strAttribute)
{
strReturn = xmlAttr.Item(i).Value ;
break;
}
}
}
}
catch(XmlException xmle)
{
throw xmle ;
}
return strReturn ;
}

#endregion
#region 读取指定接点的值
public string GetXmlNodeValue(string strNode)
{
string strReturn = String.Empty ;
try
{
//根据路径获取节点
XmlNode xmlNode = xmlDoc.SelectSingleNode(strNode) ;
if (!(xmlNode==null))
strReturn = xmlNode.InnerText ;
}
catch(XmlException xmle)
{
throw xmle ;
}
return strReturn ;
}
#endregion
#region 设置指定接点的值
public void SetXmlNodeValue(string xmlNodePath,string xmlNodeValue)
{
try
{
//可以批量为符合条件的节点进行付值
XmlNodeList xmlNode=this.xmlDoc.SelectNodes(xmlNodePath);
if (!(xmlNode==null))
{
foreach(XmlNode xn in xmlNode)
{
xn.InnerText = xmlNodeValue ;
}
}
}
catch(XmlException xmle)
{
throw xmle ;
}
}

#endregion
#region 设置接点属性值
public void SetXmlNodeAttributeValue(string xmlNodePath,string xmlNodeAttribute,string xmlNodeAttributeValue)
{
try
{
//可以批量为符合条件的节点的属性付值
XmlNodeList xmlNode=this.xmlDoc.SelectNodes(xmlNodePath);
if (!(xmlNode==null))
{
foreach(XmlNode xn in xmlNode)
{
XmlAttributeCollection xmlAttr = xn.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 获取XML文件的根元素
public XmlNode GetXmlRoot()
{
return xmlDoc.DocumentElement ;
}
#endregion

#region 在根接点下添加父接点
public void AddParentNode(string parentNode)
{
try
{
XmlNode root = GetXmlRoot() ;
XmlNode parentXmlNode = xmlDoc.CreateElement(parentNode) ;
root.AppendChild(parentXmlNode) ;
}
catch(XmlException xmle)
{
throw xmle ;
}
}

#endregion
#region 向已经存在的父接点中插入子接点
public void AddChildNode( string parentNodePath,string childnodename )
{
try
{
XmlNode parentXmlNode = xmlDoc.SelectSingleNode(parentNodePath) ;
if(!((parentXmlNode)==null))//如果此节点存在
{
XmlNode childXmlNode = xmlDoc.CreateElement(childnodename) ;
parentXmlNode.AppendChild( childXmlNode ) ;
}
else{
//如果不存在就放父节点添加
//this.GetXmlRoot().AppendChild(childXmlNode);
}
}
catch(XmlException xmle)
{
throw xmle;
}
}

#endregion
#region 向一个接点添加属性
public void AddAttribute( string NodePath , string NodeAttribute)
{
privateAddAttribute(NodePath,NodeAttribute,"");
}
private void privateAddAttribute( string NodePath , string NodeAttribute,string NodeAttributeValue)
{
try
{
XmlNode nodePath = xmlDoc.SelectSingleNode( NodePath ) ;
if (!(nodePath==null))
{
XmlAttribute nodeAttribute = this.xmlDoc.CreateAttribute(NodeAttribute);
nodeAttribute.Value=NodeAttributeValue;
nodePath.Attributes.Append(nodeAttribute) ;
}
}
catch(XmlException xmle)
{
throw xmle;
}
}
#endregion
#region 向一个接点添加属性并赋值
public void AddAttribute( string NodePath , string NodeAttribute,string NodeAttributeValue)
{
privateAddAttribute(NodePath,NodeAttribute,NodeAttributeValue);
}
#endregion

#region 删除属性
public void DeleteAttribute( string NodePath , string NodeAttribute)
{
XmlNodeList nodePath =this.xmlDoc.SelectNodes(NodePath);
if (!(nodePath==null))
{
foreach (XmlNode tempxn in nodePath)
{
XmlAttributeCollection xmlAttr = tempxn.Attributes ;
for(int i=0 ; i<xmlAttr.Count;i++)
{
if ( xmlAttr.Item(i).Name == NodeAttribute)
{
tempxn.Attributes.RemoveAt(i);
break ;
}
}
}
}
}
#endregion
#region 删除属性，当属性等于给定值时
public void DeleteAttribute( string NodePath , string NodeAttribute , string NodeAttributeValue)
{
XmlNodeList nodePath =this.xmlDoc.SelectNodes(NodePath);
if (!(nodePath==null))
{
foreach (XmlNode tempxn in nodePath)
{
XmlAttributeCollection xmlAttr = tempxn.Attributes ;
for(int i=0 ; i<xmlAttr.Count;i++)
{
if ( xmlAttr.Item(i).Name == NodeAttribute && xmlAttr.Item(i).Value==NodeAttributeValue)
{
tempxn.Attributes.RemoveAt(i);
break ;
}
}
}
}
}
#endregion

#region 删除接点
public void DeleteXmlNode(string tempXmlNode)
{
XmlNodeList nodePath =this.xmlDoc.SelectNodes(tempXmlNode);
if (!(nodePath==null))
{
foreach(XmlNode xn in nodePath)
{
xn.ParentNode.RemoveChild(xn);
}
}
}
#endregion

#region XML文档事件
private void nodeInsertEvent(Object src, XmlNodeChangedEventArgs args)
{
//保存设置
SaveXmlDocument();
}
private void nodeDeleteEvent(Object src, XmlNodeChangedEventArgs args)
{
//保存设置
SaveXmlDocument();
}
private void nodeUpdateEvent(Object src, XmlNodeChangedEventArgs args)
{
//保存设置
SaveXmlDocument();
}
#endregion

#region 保存XML文件
public void SaveXmlDocument()
{
try
{
//保存设置的结果
if( this.xmlFilePathType == enumXmlPathType.AbsolutePath )
{
Savexml( xmlFilePath ) ;
}
else if( this.xmlFilePathType == enumXmlPathType.VirtualPath )
{
Savexml(HttpContext.Current.Server.MapPath(xmlFilePath)) ;
}
}
catch(XmlException xmle)
{
throw xmle;
}
}

public void SaveXmlDocument(string tempXMLFilePath)
{
try
{
//保存设置的结果
Savexml(tempXMLFilePath);
}
catch(XmlException xmle)
{
throw xmle;
}
}

private void Savexml(string filepath)
{
xmlDoc.Save(filepath);
}

#endregion
#region 读取指定接点的全部子接点信息到Hashtable中
public Hashtable getAllChildNodesInfo(string parentNodePath,string keyName,string keyValue)
{
Hashtable hashtable = new Hashtable();
try
{
XmlNode parentXmlNode = xmlDoc.SelectSingleNode(parentNodePath);
if (!((parentXmlNode) == null))//如果此节点存在
{
foreach (XmlNode xn in parentXmlNode.ChildNodes)
{
XmlElement xe = (XmlElement)xn;
hashtable.Add(xe.GetAttribute(keyName).ToString(), xe.GetAttribute(keyValue).ToString());
}
}
else
{
//如果不存在就放父节点添加
//this.GetXmlRoot().AppendChild(childXmlNode);
}
}
catch (XmlException xmle)
{
throw xmle;
}
return hashtable;
}

#endregion
#region 读取二级接点指定的属性到ArrayList中
public ArrayList GetSecondaryNodeAttributeValue(string attributeName)
{
ArrayList al = new ArrayList();
XmlNode xn = GetXmlRoot();
XmlNodeList xnl = xn.ChildNodes;
foreach(XmlNode tempxn in xnl)
{
XmlElement xe = (XmlElement)tempxn;
al.Add(xe.GetAttribute(attributeName).ToString());
}
return al;
}
#endregion
#region 插入新的接点，并对新的接点增加属性、设置属性值
/// <summary>
/// GeneralXu 07-04-23
/// </summary>
/// <param name="parentNodePath"></param>
/// <param name="childnodename"></param>
/// <param name="attributeList">这里是属性和属性值列表信息，格式是“属性名：属性值”</param>
public void AddNodeAndSetAttribulteValue(string parentNodePath, string childnodename,ArrayList attributeList)
{
try
{
XmlNode parentXmlNode = xmlDoc.SelectSingleNode(parentNodePath);
if (!((parentXmlNode) == null))//如果此节点存在
{
XmlNode childXmlNode = xmlDoc.CreateElement(childnodename);
if ((attributeList != null) && (attributeList.Count > 0))
{
for (int i = 0; i < attributeList.Count; i++)
{
string[] strAttriNameValue = null;
strAttriNameValue = attributeList[i].ToString().Split(":".ToCharArray());
XmlAttribute xa = xmlDoc.CreateAttribute(strAttriNameValue[0].ToString());
xa.Value = strAttriNameValue[1].ToString();
childXmlNode.Attributes.Append(xa);
}
}
parentXmlNode.AppendChild(childXmlNode);
}
else
{
//如果不存在就放父节点添加
//this.GetXmlRoot().AppendChild(childXmlNode);
}
}
catch (XmlException xmle)
{
throw xmle;
}
}
#endregion

}
}