public class XMLHelp:Object
{
protected string strXmlFile;
protected XmlDocument objXmlDoc = new XmlDocument();
/// <summary>
/// xml文档根节点.
/// </summary>
private XmlElement _element;
public XMLHelp(string XmlFile, Boolean bOverWrite, string sRoot)
{
try
{
//如果覆盖模式，则强行创建一个xml文档
if (bOverWrite)
{
objXmlDoc.AppendChild(objXmlDoc.CreateXmlDeclaration("1.0", "utf-8", null));//设置xml的版本，格式信息
objXmlDoc.AppendChild(objXmlDoc.CreateElement("", sRoot, ""));//创建根元素
objXmlDoc.Save(XmlFile);//保存
}
else //否则，检查文件是否存在，不存在则创建
{
if (!(File.Exists(XmlFile)))
{
objXmlDoc.AppendChild(objXmlDoc.CreateXmlDeclaration("1.0", "utf-8", null));
objXmlDoc.AppendChild(objXmlDoc.CreateElement("", sRoot, ""));
objXmlDoc.Save(XmlFile);
}
}
objXmlDoc.Load(XmlFile);
}
catch (System.Exception ex)
{
throw ex;
}
strXmlFile = XmlFile;
}
/// <summary>
/// 根据xPath值，返回xPath下的所有下级子结节到一个DataView
/// </summary>
/// <param name="XmlPathNode">xPath值</param>
/// <returns>有数据则返回DataView，否则返回null</returns>
public DataView GetData(string XmlPathNode)
{
//查找数据。返回一个DataView
DataSet ds = new DataSet();
try
{
StringReader read = new StringReader(objXmlDoc.SelectSingleNode(XmlPathNode).OuterXml);
ds.ReadXml(read);
return ds.Tables[0].DefaultView;
}
catch
{
//throw;
return null;
}
}
/// <summary>
/// 更新节点内容
/// </summary>
/// <param name="xmlPathNode"></param>
/// <param name="content"></param>
public void UpdateNode(string xmlPathNode, string content)
{
objXmlDoc.SelectSingleNode(xmlPathNode).InnerText = content;
}
/// <summary>
/// 更新节点的某个属性
/// </summary>
/// <param name="xmlPathNode">要操作的节点</param>
/// <param name="AttribName">属性名</param>
/// <param name="AttribValue">属性值</param>
public void UpdateNode(string xmlPathNode, string AttribName, string AttribValue)
{
((XmlElement)(objXmlDoc.SelectSingleNode(xmlPathNode))).SetAttribute(AttribName, AttribValue);
}
/// <summary>
/// 修改节点(同步更新内容和属性)
/// </summary>
/// <param name="xmlPathNode">要操作节点的xpath语句</param>
/// <param name="arrAttribName">属性名称字符串数组</param>
/// <param name="arrAttribContent">属性内容字符串数组</param>
/// <param name="content">节点内容</param>
public void UpdateNode(string xmlPathNode, string[] arrAttribName, string[] arrAttribContent, string content)
{
XmlNode xn = objXmlDoc.SelectSingleNode(xmlPathNode);
if (xn != null)
{
xn.InnerText = content;
xn.Attributes.RemoveAll();
for (int i = 0; i <= arrAttribName.GetUpperBound(0); i++)
{
((XmlElement)(xn)).SetAttribute(arrAttribName[i], arrAttribContent[i]);
}
}
}
/// <summary>
/// 移除选定节点集的所有属性
/// </summary>
/// <param name="xmlPathNode"></param>
public void RemoveAllAttribute(string xmlPathNode)
{
XmlNodeList xnl = objXmlDoc.SelectNodes(xmlPathNode);
foreach (XmlNode xn in xnl)
{
xn.Attributes.RemoveAll();
}
}
public void DeleteNode(string Node)
{
//刪除一个节点。
try
{
string mainNode = Node.Substring(0, Node.LastIndexOf("/"));
objXmlDoc.SelectSingleNode(mainNode).RemoveChild(objXmlDoc.SelectSingleNode(Node));
}
catch
{
//throw;
return;
}
}
public void InsertNodeWithChild(string mainNode, string ChildNode, string Element, string Content)
{
//插入一节点和此节点的一子节点。
XmlNode objRootNode = objXmlDoc.SelectSingleNode(mainNode);
XmlElement objChildNode = objXmlDoc.CreateElement(ChildNode);
objRootNode.AppendChild(objChildNode);//插入节点
XmlElement objElement = objXmlDoc.CreateElement(Element);
objElement.InnerText = Content;
objChildNode.AppendChild(objElement);//插入子节点
}
/// <summary>
/// 插入一个节点，带一个Attribute和innerText
/// </summary>
/// <param name="mainNode"></param>
/// <param name="Element">节点名称</param>
/// <param name="Attrib">Attribute名称</param>
/// <param name="AttribContent">Attribute值</param>
/// <param name="Content">innerText值</param>
public void InsertNode(string mainNode, string Element, string Attrib, string AttribContent, string Content)
{
XmlNode objNode = objXmlDoc.SelectSingleNode(mainNode);
XmlElement objElement = objXmlDoc.CreateElement(Element);
objElement.SetAttribute(Attrib, AttribContent);
objElement.InnerText = Content;
objNode.AppendChild(objElement);
}
/// <summary>
/// 插入一个节点，带一个Attribute
/// </summary>
/// <param name="mainNode"></param>
/// <param name="Element">节点名称</param>
/// <param name="Attrib">Attribute名称</param>
/// <param name="AttribContent">Attribute值</param>
public void InsertNode(string mainNode, string Element, string Attrib, string AttribContent)
{
XmlNode objNode = objXmlDoc.SelectSingleNode(mainNode);
XmlElement objElement = objXmlDoc.CreateElement(Element);
objElement.SetAttribute(Attrib, AttribContent);
objNode.AppendChild(objElement);
}
/// <summary>
/// 插入一个节点
/// </summary>
/// <param name="mainNode"></param>
/// <param name="Element">节点名称</param>
public void InsertNode(string mainNode, string Element)
{
XmlNode objNode = objXmlDoc.SelectSingleNode(mainNode);
XmlElement objElement = objXmlDoc.CreateElement(Element);
objNode.AppendChild(objElement);
}
//<summary>
//插入一个节点，带多个属性和一个inner text
//</summary>
public void InsertNode(string mainNode, string elementName, string[] arrAttributeName, string[] arrAttributeContent, string elementContent)
{
try
{
XmlNode objNode = objXmlDoc.SelectSingleNode(mainNode);
XmlElement objElement = objXmlDoc.CreateElement(elementName);
for (int i = 0; i <= arrAttributeName.GetUpperBound(0); i++)
{
objElement.SetAttribute(arrAttributeName[i], arrAttributeContent[i]);
}
objElement.InnerText = elementContent;
objNode.AppendChild(objElement);
}
catch
{
throw;
//string t = mainNode;
//;
}
}
///<summary>
///插入一个节点，带多个属性
///</summary>
public void InsertNode(string mainNode, string elementName, string[] arrAttributeName, string[] arrAttributeContent)
{
try
{
XmlNode objNode = objXmlDoc.SelectSingleNode(mainNode);
XmlElement objElement = objXmlDoc.CreateElement(elementName);
for (int i = 0; i <= arrAttributeName.GetUpperBound(0); i++)
{
objElement.SetAttribute(arrAttributeName[i], arrAttributeContent[i]);
}
//objElement.InnerText = elementContent;
objNode.AppendChild(objElement);
}
catch
{
throw;
//string t = mainNode;
//;
}
}
/// <summary>
/// 插入子节点(带多个属性)
/// </summary>
/// <param name="parentNode">要插入的父节点</param>
/// <param name="elementName">插入的节点名称</param>
/// <param name="arrAttributeName">属性名称[数组]</param>
/// <param name="arrAttributeContent">属性内容[数组]</param>
/// <param name="elementContent">节点内容</param>
public void AddChildNode(string parentNodePath, string elementName, string[] arrAttributeName, string[] arrAttributeContent, string elementContent)
{
try
{
XmlNode parentNode = objXmlDoc.SelectSingleNode(parentNodePath);
XmlElement objChildElement = objXmlDoc.CreateElement(elementName);
for (int i = 0; i <= arrAttributeName.GetUpperBound(0); i++)
{
objChildElement.SetAttribute(arrAttributeName[i], arrAttributeContent[i]);
}
objChildElement.InnerText = elementContent;
parentNode.AppendChild(objChildElement);
}
catch
{
return;
}
}
/// <summary>
/// 插入子节点(将内容以CData形式写入)
/// </summary>
/// <param name="parentNode">要插入的父节点</param>
/// <param name="elementName">插入的节点名称</param>
/// <param name="elementContent">节点内容</param>
public void AddChildNodeCData(string parentNodePath, string elementName, string elementContent)
{
try
{
XmlNode parentNode = objXmlDoc.SelectSingleNode(parentNodePath);
XmlElement objChildElement = objXmlDoc.CreateElement(elementName);
//写入cData数据
XmlCDataSection xcds = objXmlDoc.CreateCDataSection(elementContent);
objChildElement.AppendChild(xcds);
parentNode.AppendChild(objChildElement);
}
catch
{
return;
}
}
/// <summary>
/// 插入子节点(仅内容，不带属性)
/// </summary>
/// <param name="parentNode">要插入的父节点</param>
/// <param name="elementName">插入的节点名称</param>
/// <param name="elementContent">节点内容</param>
public void AddChildNode(string parentNodePath, string elementName, string elementContent)
{
try
{
XmlNode parentNode = objXmlDoc.SelectSingleNode(parentNodePath);
XmlElement objChildElement = objXmlDoc.CreateElement(elementName);
objChildElement.InnerText = elementContent;
parentNode.AppendChild(objChildElement);
}
catch
{
return;
}
}
/// <summary>
/// 根据xpath值查找节点
/// </summary>
/// <param name="NodePath">要查找节点的xpath值</param>
/// <returns>找到返回true,否则返回true</returns>
public bool FindNode(string NodePath)
{
try
{
if (objXmlDoc.SelectSingleNode(NodePath) != null)
{
return true;
}
else
{
return false;
}
}
catch
{
return false;
}
}
/// <summary>
///保存文档
/// </summary>
public void Save()
{
//保存文档。
try
{
objXmlDoc.Save(strXmlFile);
}
catch (System.Exception ex)
{
throw ex;
}
objXmlDoc = null;
}
///// <summary>
///// 获取指定路径节点下孩子节点列表
///// </summary>
///// <param name="xmlFileName"></param>
///// <param name="xPath"></param>
///// <returns></returns>
//public XmlNodeList GetXmlNodeList(string xPath)
//{
// XmlDocument xmldocument = new XmlDocument();
// //加载xml文档
// xmldocument.Load(strXmlFile);
// try
// {
// XmlNodeList xmlnodelist = xmldocument.SelectNodes(xPath);
// return xmlnodelist;
// }
// catch
// {
// return null;
// }
//}
/// <summary>
/// 获取指定目录下所有子节点的值
/// </summary>
/// <param name="nodeDir">节点目录</param>
/// <returns></returns>
public XmlNodeList GetXmlNodeList(string nodeDir)
{
List<XmlNode> lstNode = new List<XmlNode>();
try
{
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(strXmlFile);
//XmlNodeList nodeList = xmlDoc.SelectSingleNode(nodeDir).ChildNodes;//获取bookstore节点的所有子节点
return xmlDoc.SelectSingleNode(nodeDir).ChildNodes;
//foreach (XmlNode xn in nodeList) //遍历所有子节点
//{
// lstNode.Add(xn);
//}
}
catch (Exception)
{
throw;
}
}
/// <summary>
/// 获取指定目录下所有子节点的值
/// </summary>
/// <param name="nodeDir">节点目录</param>
/// <returns></returns>
public Hashtable GetNodeList(string nodeDir)
{
Hashtable strNodeList = new Hashtable();
try
{
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(strXmlFile);
XmlNodeList nodeList = xmlDoc.SelectSingleNode(nodeDir).ChildNodes;//获取bookstore节点的所有子节点
foreach (XmlNode xn in nodeList) //遍历所有子节点
{
XmlElement xe = (XmlElement)xn; //将子节点类型转换为XmlElement类型
if (xe.GetAttribute("Name").ToString().Trim().Length > 0)
strNodeList.Add(xe.GetAttribute("Name").ToString(), xe.InnerText.Trim());
else
strNodeList.Add(xe.Name.Trim(), xe.InnerText.Trim());
}
}
catch (Exception)
{
throw;
}
return strNodeList;
}
/// <summary>
/// 获取指定目录下所有子节点的值
/// </summary>
/// <param name="nodeDir">节点目录</param>
/// <returns></returns>
public Hashtable GetNodeListByValue(string nodeDir)
{
Hashtable strNodeList = new Hashtable();
try
{
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(strXmlFile);
XmlNodeList nodeList = xmlDoc.SelectSingleNode(nodeDir).ChildNodes;//获取bookstore节点的所有子节点
foreach (XmlNode xn in nodeList) //遍历所有子节点
{
XmlElement xe = (XmlElement)xn; //将子节点类型转换为XmlElement类型
if (xe.InnerText.Trim().Length > 0 && xe.Name.Length > 0) strNodeList.Add(xe.InnerText.Trim(), xe.Name);
}
}
catch (Exception)
{
throw;
}
return strNodeList;
}
/// <summary>
/// 获取指定目录下所有子节点的值
/// </summary>
/// <param name="nodeDir">节点目录</param>
/// <returns></returns>
public Dictionary<string, string> GetNodeListByValueToDictionary(string nodeDir)
{
Dictionary<string, string> strNodeList = new Dictionary<string, string>();
try
{
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(strXmlFile);
XmlNodeList nodeList = xmlDoc.SelectSingleNode(nodeDir).ChildNodes;//获取bookstore节点的所有子节点
foreach (XmlNode xn in nodeList) //遍历所有子节点
{
XmlElement xe = (XmlElement)xn; //将子节点类型转换为XmlElement类型
if (xe.InnerText.Trim().Length > 0 && xe.Name.Length > 0) strNodeList.Add(xe.InnerText.Trim(), xe.Name);
}
}
catch (Exception)
{
throw;
}
return strNodeList;
}
/// <summary>
/// 获取指定节点的值
/// </summary>
/// <param name="nodeName">节点名称</param>
/// <param name="value">设置后的值</param>
/// <param name="nodeDir">指定节点所在的节点目录</param>
/// <returns></returns>
public string GetNodeValue(string nodeName, string nodeDir)
{
string value = null;
try
{
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(strXmlFile);
//XmlNodeList nodeList = xmlDoc.SelectSingleNode(nodeDir).ChildNodes;//获取bookstore节点的所有子节点
XmlNodeList nodeList = xmlDoc.SelectNodes(nodeDir);//获取bookstore节点的所有子节点
foreach (XmlNode xn in nodeList) //遍历所有子节点
{
XmlElement xe = (XmlElement)xn; //将子节点类型转换为XmlElement类型
if (xe.Name == nodeName)
{
value = xe.InnerText.Trim();
break;
}
}
}
catch (Exception exp)
{
throw exp;
}
return value;
}
/// <summary>
/// 获取指定节点下面对应属性的值
/// </summary>
/// <param name="nodeName">节点名称</param>
/// <param name="nodeDir">指定节点所在的节点目录</param>
/// <param name="attribute">节点对应的属性名称</param>
/// <returns></returns>
public string GetNodeValue(string nodeName, string nodeDir, string attribute)
{
string value = null;
try
{
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(strXmlFile);
XmlNodeList nodeList = xmlDoc.SelectSingleNode(nodeDir).ChildNodes;//获取bookstore节点的所有子节点
foreach (XmlNode xn in nodeList) //遍历所有子节点
{
XmlElement xe = (XmlElement)xn; //将子节点类型转换为XmlElement类型
if (xe.Name == nodeName)
{
//value = xe.InnerText.Trim();
value = (xe).Attributes[attribute].Value;
break;
}
}
}
catch (Exception exp)
{
throw exp;
}
return value;
}
/// <summary>
/// 获取指定路径节点
/// </summary>
/// <param name="xPath"></param>
/// <returns></returns>
public static XmlNode GetXmlNode(string xmlFileName, string xPath)
{
XmlDocument xmldocument = new XmlDocument();
//加载xml文档
xmldocument.Load(xmlFileName);
try
{
XmlNode xmlnode = xmldocument.SelectSingleNode(xPath);
return xmlnode;
}
catch
{
return null;
}
}
/// <summary>
/// 获取指定路径节点下孩子节点列表
/// </summary>
/// <param name="xmlFileName"></param>
/// <param name="xPath"></param>
/// <returns></returns>
public static XmlNodeList GetXmlNodeList(string xmlFileName, string xPath)
{
XmlDocument xmldocument = new XmlDocument();
//加载xml文档
xmldocument.Load(xmlFileName);
try
{
XmlNodeList xmlnodelist = xmldocument.SelectNodes(xPath);
return xmlnodelist;
}
catch
{
return null;
}
}
/// <summary>
/// 获取指定路径节点的属性与指定属性名匹配
/// </summary>
/// <param name="xmlFileName"></param>
/// <param name="xPath">要匹配的XPath表达式(例如:"//节点名//子节点名</param>
/// <param name="attributeName">指定的属性名称</param>
/// <returns></returns>
public static XmlAttribute GetXmlAttribute(string xmlFileName, string xPath, string attributeName)
{
XmlAttribute xmlattribute = null;
XmlDocument xmldocument = new XmlDocument();
xmldocument.Load(xmlFileName);
try
{
XmlNode xmlnode = xmldocument.SelectSingleNode(xPath);
if (xmlnode != null)
{
if (xmlnode.Attributes.Count > 0)
{
xmlattribute = xmlnode.Attributes[attributeName];
}
}
}
catch (Exception err)
{
throw err;
}
return xmlattribute;
}
/// <summary>
/// 获取指定节点的属性集合
/// </summary>
/// <param name="xmlFileName"></param>
/// <param name="xPath"></param>
/// <returns></returns>
public static XmlAttributeCollection GetNodeAttributes(string xmlFileName, string xPath)
{
XmlAttributeCollection xmlattributes = null;
XmlDocument xmldocument = new XmlDocument();
xmldocument.Load(xmlFileName);
try
{
XmlNode xmlnode = xmldocument.SelectSingleNode(xPath);
if (xmlnode != null)
{
if (xmlnode.Attributes.Count > 0)
{
xmlattributes = xmlnode.Attributes;
}
}
}
catch (Exception err)
{
throw err;
}
return xmlattributes;
}
/// <summary>
/// 更新指定节点的某一属性设定其属性值value
/// </summary>
/// <param name="xmlFileName">xml文档路径</param>
/// <param name="xPath"></param>
/// <param name="attributeOldeName">旧属性名称</param>
/// <param name="attributeNewName">新属性名称</param>
/// <param name="value">属性值</param>
/// <returns>成功返回true,失败返回false</returns>
public static bool UpdateAttribute(string xmlFileName, string xPath, string attributeName, string value)
{
bool isSuccess = false;
XmlDocument xmldocument = new XmlDocument();
xmldocument.Load(xmlFileName);
try
{
XmlNode xmlnode = xmldocument.SelectSingleNode(xPath);
if (xmlnode != null)
{
foreach (XmlAttribute attribute in xmlnode.Attributes)
{
if (attribute.Name.ToString().ToLower() == attributeName.ToLower())
{
isSuccess = true;
attribute.Value = value;
xmldocument.Save(xmlFileName);
break;
}
}
}
}
catch (Exception err)
{
throw err;
}
return isSuccess;
}
/// <summary>
/// 删除指定节点的所有属性
/// </summary>
/// <param name="xmlFileName"></param>
/// <param name="xPath"></param>
/// <returns>成功返回true,失败返回false</returns>
public static bool DeleteAttributes(string xmlFileName, string xPath)
{
bool isSuccess = false;
XmlDocument xmldocument = new XmlDocument();
xmldocument.Load(xmlFileName);
try
{
XmlNode xmlnode = xmldocument.SelectSingleNode(xPath);
if (xmlnode != null)
{
if (xmlnode.Attributes.Count > 0)
{
xmlnode.Attributes.RemoveAll();
xmldocument.Save(xmlFileName);
isSuccess = true;
}
}
}
catch (Exception err)
{
throw err;
}
return isSuccess;
}
/// <summary>
/// 删除匹配属性名称的指定节点的属性
/// </summary>
/// <param name="xmlFileName"></param>
/// <param name="xPath"></param>
/// <param name="attributeName"></param>
/// <returns></returns>
public static bool DeleteOneAttribute(string xmlFileName, string xPath, string attributeName)
{
bool isSuccess = false;
XmlDocument xmldocument = new XmlDocument();
xmldocument.Load(xmlFileName);
XmlAttribute xmlAttribute = null;
try
{
XmlNode xmlnode = xmldocument.SelectSingleNode(xPath);
if (xmlnode != null)
{
if (xmlnode.Attributes.Count > 0)
{
foreach (XmlAttribute attribute in xmlnode.Attributes)
{
if (attribute.Name.ToLower() == attributeName.ToLower())
{
xmlAttribute = attribute;
break;
}
}
}
if (xmlAttribute != null)
{
xmlnode.Attributes.Remove(xmlAttribute);
xmldocument.Save(xmlFileName);
isSuccess = true;
}
}
}
catch (Exception err)
{
throw err;
}
return isSuccess;
}
/// <summary>
/// 创建指定节点的属性,如果属性存在则不创建
/// </summary>
/// <param name="xmlFileName"></param>
/// <param name="xPath"></param>
/// <param name="attributeName"></param>
/// <param name="value"></param>
/// <returns></returns>
public static bool AddAttribute(string xmlFileName, string xPath, string attributeName, string value)
{
bool isSuccess = false;
XmlDocument xmldocument = new XmlDocument();
xmldocument.Load(xmlFileName);
try
{
XmlNode xmlnode = xmldocument.SelectSingleNode(xPath);
if (xmlnode != null)
{
if (xmlnode.Attributes.Count > 0)//遍历判断有无此属性
{
foreach (XmlAttribute attribute in xmlnode.Attributes)
{
if (attribute.Name.ToLower() == attributeName.ToLower())
{
//有则不改，直接返回true;
return true;
}
}
}
XmlAttribute xmlAttribute = xmldocument.CreateAttribute(attributeName);
xmlAttribute.Value = value;
xmlnode.Attributes.Append(xmlAttribute);
xmldocument.Save(xmlFileName);
isSuccess = true;
}
}
catch (Exception err)
{
throw err;
}
return isSuccess;
}
/// <summary>
/// 为某一指定路径节点下添加新的节点，如果该节点存在，则不添加
/// </summary>
/// <param name="xmlFileName">xml文档路径</param>
/// <param name="xPath">需要添加节点的路径</param>
/// <param name="nodeName">节点名称</param>
/// <param name="innerText">节点文本值</param>
/// <returns>成功返回true,存在返回false</returns>
public static bool AddNode(string xmlFileName, string xPath, string nodeName, string innerText)
{
bool isSuccess = false;
bool isExisitNode = false;
XmlDocument xmldocument = new XmlDocument();
xmldocument.Load(xmlFileName);
try
{
XmlNode xmlnode = xmldocument.SelectSingleNode(xPath);
if (xmlnode != null)
{
isExisitNode = true;
}
if (!isExisitNode)
{
XmlElement subElement = xmldocument.CreateElement(nodeName);
subElement.InnerText = innerText;
xmlnode.AppendChild(subElement);
isSuccess = true;
xmldocument.Save(xmlFileName);
}
}
catch (Exception err)
{
throw err;
}
return isSuccess;
}
/// <summary>
/// 查找指定的节点，更新其节点值
/// </summary>
/// <param name="xmlFileName"></param>
/// <param name="xPath"></param>
/// <param name="nodeName"></param>
/// <param name="innerText"></param>
/// <returns></returns>
public static bool UpdateNode(string xmlFileName, string xPath, string nodeName, string innerText)
{
bool isSuccess = false;
bool isExisitNode = false;
XmlDocument xmldocument = new XmlDocument();
xmldocument.Load(xmlFileName);
XmlNode xmlnode = xmldocument.SelectSingleNode(xPath);
try
{
if (xmlnode != null)
{
isExisitNode = true;
}
if (!isExisitNode)
{
xmlnode.InnerText = innerText;
isSuccess = true;
xmldocument.Save(xmlFileName);
}
}
catch (Exception err)
{
throw err;
}
return isSuccess;
}
/// <summary>
/// 删除指定节点名称为nodeName的所有节点，如果该节点有子节点，则不能删除
/// </summary>
/// <param name="xmlFileName"></param>
/// <param name="xPath"></param>
/// <param name="nodeName"></param>
/// <returns></returns>
public static bool deleteNode(string xmlFileName, string xPath, string nodeName)
{
bool isSuccess = false;
XmlDocument xmldocument = new XmlDocument();
xmldocument.Load(xmlFileName);
try
{
XmlNode xmlnode = xmldocument.SelectSingleNode(xPath);
if (xmlnode != null)
{
if (xmlnode.HasChildNodes)
{
isSuccess = false;
}
else
{
xmlnode.ParentNode.RemoveChild(xmlnode);//删除节点
isSuccess = true;
xmldocument.Save(xmlFileName);
}
}
}
catch (Exception err)
{
throw err;
}
return isSuccess;
}
/// <summary>
/// 根据指定节点名称更新其下指定的子节点的值
/// </summary>
/// <param name="xmlFileName"></param>
/// <param name="xPath"></param>
/// <param name="nodeName"></param>
/// <param name="innerText"></param>
/// <returns></returns>
public static bool UpdateChildNode(string xmlFileName, string xPath, string nodeName, string childName, string innerText)
{
bool isSuccess = false;
XmlDocument xmldocument = new XmlDocument();
xmldocument.Load(xmlFileName);
try
{
XmlNode xmlnode = xmldocument.SelectSingleNode(xPath);
if (xmlnode != null)
{
foreach (XmlNode node in xmlnode.ChildNodes)
{
if (node.Name.ToLower() == childName.ToLower())
{
node.InnerText = innerText;
xmldocument.Save(xmlFileName);
isSuccess = true;
}
}
}
}
catch (Exception err)
{
throw err;
}
return isSuccess;
}
#region 创建XML的根节点
/// <summary>
/// 创建XML的根节点
/// </summary>
private void CreateXMLElement()
{
//创建一个XML对象
objXmlDoc = new XmlDocument();
if (File.Exists(strXmlFile))
{
//加载XML文件
objXmlDoc.Load(this.strXmlFile);
}
//为XML的根节点赋值
_element = objXmlDoc.DocumentElement;
}
#endregion
#region XML文档创建和节点或属性的添加、修改
/// <summary>
/// 创建一个XML文档
/// </summary>
/// <param name="xmlFileName">XML文档完全文件名(包含物理路径)</param>
/// <param name="rootNodeName">XML文档根节点名称(须指定一个根节点名称)</param>
/// <param name="version">XML文档版本号(必须为:"1.0")</param>
/// <param name="encoding">XML文档编码方式</param>
/// <param name="standalone">该值必须是"yes"或"no",如果为null,Save方法不在XML声明上写出独立属性</param>
/// <returns>成功返回true,失败返回false</returns>
public static bool CreateXmlDocument(string xmlFileName, string rootNodeName, string version, string encoding, string standalone)
{
bool isSuccess = false;
try
{
XmlDocument xmlDoc = new XmlDocument();
XmlDeclaration xmlDeclaration = xmlDoc.CreateXmlDeclaration(version, encoding, standalone);
XmlNode root = xmlDoc.CreateElement(rootNodeName);
xmlDoc.AppendChild(xmlDeclaration);
xmlDoc.AppendChild(root);
xmlDoc.Save(xmlFileName);
isSuccess = true;
}
catch (Exception ex)
{
throw ex; //这里可以定义你自己的异常处理
}
return isSuccess;
}
#endregion
}
浙公网安备 33010602011771号