C#操作xml完整类文件

C#操作xml完整类文件

xml_oper.cs
using ...System;
using System.Data;
using System.Web;
using System.Xml;
/**//// <summary>
/// 类名:xml操作类
/// 作者:虫
/// 时间:2008.8.31
/// </summary>
public class xml_oper
...{
    private XmlDocument xmlDoc;
public xml_oper()
...{
}
    /**//// <summary>
    /// 加载xml文件
    /// </summary>
    /// <param name="path">xml文件的物理路径</param>
    private void LoadXml(string path, string node_root)
    ...{
        xmlDoc = new XmlDocument();
        //判断xml文件是否存在
        if (!System.IO.File.Exists(path))
        ...{
            //创建xml 声明节点
            XmlNode xmlnode = xmlDoc.CreateNode(System.Xml.XmlNodeType.XmlDeclaration, "", "");
            //添加上述创建和 xml声明节点
            xmlDoc.AppendChild(xmlnode);
            //创建xml dbGuest 元素（根节点）
            XmlElement xmlelem = xmlDoc.CreateElement("", node_root, "");
            xmlDoc.AppendChild(xmlelem);
            try
            ...{
                xmlDoc.Save(path);
            }
            catch (Exception ex)
            ...{
                throw ex;
            }
            xmlDoc.Load(path);
        }
        else
        ...{
            //加载xml文件
            xmlDoc.Load(path);
        }
    }
    /**//// <summary>
    /// 添加xml子节点
    /// </summary>
    /// <param name="path">xml文件的物理路径</param>
    /// <param name="node_root">根节点名称</param>
    /// <param name="node_name">添加的子节点名称</param>
    /// <param name="node_text">子节点文本</param>
    public void addElement(string path, string node_root, string node_name, string node_text,string att_name,string att_value)
    ...{
        LoadXml(path, node_root);
        XmlNodeList nodeList = xmlDoc.SelectSingleNode(node_root).ChildNodes;//获取bookstore节点的所有子节点
        //判断是否有节点,有节点就遍历所有子节点,看看有没有重复节点,没节点就添加一个新节点
        if (nodeList.Count > )
        ...{
            foreach (XmlNode xn in nodeList)//遍历所有子节点
            ...{
                XmlElement xe = (XmlElement)xn;//将子节点类型转换为XmlElement类型
                if (xe.GetAttribute(att_name) != att_value)
                ...{
                    XmlNode xmldocSelect = xmlDoc.SelectSingleNode(node_root);  //选中根节点
                    XmlElement son_node = xmlDoc.CreateElement(node_name);    //添加子节点
                    son_node.SetAttribute(att_name, att_value);    //设置属性
                    son_node.InnerText = node_text;    //添加节点文本
                    xmldocSelect.AppendChild(son_node);      //添加子节点
                    xmlDoc.Save(path);          //保存xml文件
                    break;
                }
            }
        }
        else
        ...{
            XmlNode xmldocSelect = xmlDoc.SelectSingleNode(node_root);  //选中根节点
            XmlElement son_node = xmlDoc.CreateElement(node_name);    //添加子节点
            son_node.SetAttribute(att_name, att_value);    //设置属性
            son_node.InnerText = node_text;    //添加节点文本
            xmldocSelect.AppendChild(son_node);      //添加子节点
            xmlDoc.Save(path);          //保存xml文件
        }
    }
    /**//// <summary>
    /// 修改节点的内容
    /// </summary>
    /// <param name="path">xml文件的物理路径</param>
    /// <param name="node_root">根节点名称</param>
    /// <param name="new_text">节点的新内容</param>
    /// <param name="att_name">节点的属性名</param>
    /// <param name="att_value">节点的属性值</param>
    public void UpdateElement(string path, string node_root, string new_text, string att_name, string att_value)
    ...{
        LoadXml(path, node_root);
        XmlNodeList nodeList = xmlDoc.SelectSingleNode(node_root).ChildNodes;//获取bookstore节点的所有子节点
        foreach (XmlNode xn in nodeList)//遍历所有子节点
        ...{
            XmlElement xe = (XmlElement)xn;//将子节点类型转换为XmlElement类型
            if (xe.GetAttribute(att_name) == att_value)
            ...{
                xe.InnerText = new_text;    //内容赋值
                xmlDoc.Save(path);//保存
                break;
            }
        }

    }
    /**//// <summary>
    /// 删除节点
    /// </summary>
    /// <param name="path">xml文件的物理路径</param>
    /// <param name="node_root">根节点名称</param>
    /// <param name="att_name">节点的属性名</param>
    /// <param name="att_value">节点的属性值</param>
    public void deleteNode(string path, string node_root, string att_name, string att_value)
    ...{
        LoadXml(path, node_root);
        XmlNodeList nodeList = xmlDoc.SelectSingleNode(node_root).ChildNodes;
        XmlNode root = xmlDoc.SelectSingleNode(node_root);
        foreach (XmlNode xn in nodeList)
        ...{
            XmlElement xe = (XmlElement)xn;
            if (xe.GetAttribute(att_name) == att_value)
            ...{
                //xe.RemoveAttribute("name");//删除name属性
                xe.RemoveAll();//删除该节点的全部内容
                root.RemoveChild(xe);
                xmlDoc.Save(path);//保存
                break;
            }
        }
    }
}
  

C#解析XML基础

(转) C#解析XML基础

用的是一种很笨的方法，但可以帮助初学者了解访问XML节点的过程。
已知有一个XML文件（bookstore.xml）如下：

 <?xml version="1.0" encoding="gb2312"?>
  <bookstore>
   <book genre="fantasy" ISBN="2-3631-4">
     <title>Oberon's Legacy</title>
     <author>Corets, Eva</author>
     <price>5.95</price>
   </book>
  </bookstore>

 、往<bookstore>节点中插入一个<book>节点：

   XmlDocument xmlDoc=new XmlDocument();
     xmlDoc.Load("bookstore.xml");
     XmlNode root=xmlDoc.SelectSingleNode("bookstore");//查找<bookstore>
      XmlElement xe1=xmlDoc.CreateElement("book");//创建一个<book>节点
      xe1.SetAttribute("genre","李赞红");//设置该节点genre属性
      xe1.SetAttribute("ISBN","2-3631-4");//设置该节点ISBN属性
      XmlElement xesub1=xmlDoc.CreateElement("title");
     xesub1.InnerText="CS从入门到精通";//设置文本节点
      xe1.AppendChild(xesub1);//添加到<book>节点中
     XmlElement xesub2=xmlDoc.CreateElement("author");
    xesub2.InnerText="候捷";
    xe1.AppendChild(xesub2);
    XmlElement xesub3=xmlDoc.CreateElement("price");
    xesub3.InnerText="58.3";
    xe1.AppendChild(xesub3);
    root.AppendChild(xe1);//添加到<bookstore>节点中
     xmlDoc.Save("bookstore.xml");

 //================ 

结果为：

  <?xml version="1.0" encoding="gb2312"?>
   <bookstore>
    <book genre="fantasy" ISBN="2-3631-4">
      <title>Oberon's Legacy</title>
      <author>Corets, Eva</author>
      <price>5.95</price>
    </book>
    <book genre="李赞红" ISBN="2-3631-4">
      <title>CS从入门到精通</title>
     <author>候捷</author>
     <price>58.3</price>
   </book>
  </bookstore>

、修改节点：将genre属性值为“李赞红“的节点的genre值改为“update李赞红”，将该节点的子节点<author>的文本修改为“亚胜”。

  //获取bookstore节点的所有子节点
   XmlNodeList nodeList=xmlDoc.SelectSingleNode("bookstore").ChildNodes;
     foreach(XmlNode xn in nodeList)//遍历所有子节点
      {
      XmlElement xe=(XmlElement)xn;//将子节点类型转换为XmlElement类型
       if(xe.GetAttribute("genre")=="李赞红")//如果genre属性值为“李赞红”
       {
       xe.SetAttribute("genre","update李赞红");//则修改该属性为“update李赞红”
        XmlNodeList nls=xe.ChildNodes;//继续获取xe子节点的所有子节点
       foreach(XmlNode xn1 in nls)//遍历
       {
       XmlElement xe2=(XmlElement)xn1;//转换类型
        if(xe2.Name=="author")//如果找到
        {
        xe2.InnerText="亚胜";//则修改
         break;//找到退出来就可以了
        }
      }
      break;
     }
    }
    xmlDoc.Save("bookstore.xml");//保存。

  //=================
最后结果为：

  <?xml version="1.0" encoding="gb2312"?>
   <bookstore>
    <book genre="fantasy" ISBN="2-3631-4">
      <title>Oberon's Legacy</title>
      <author>Corets, Eva</author>
      <price>5.95</price>
    </book>
    <book genre="update李赞红" ISBN="2-3631-4">
      <title>CS从入门到精通</title>
     <author>亚胜</author>
     <price>58.3</price>
   </book>
  </bookstore>

  、删除 <book genre="fantasy" ISBN="2-3631-4">节点的genre属性，删除 <book genre="update李赞红" ISBN="2-3631-4">节点。

  XmlNodeList xnl=xmlDoc.SelectSingleNode("bookstore").ChildNodes;
     foreach(XmlNode xn in xnl)
     {
      XmlElement xe=(XmlElement)xn;
   if(xe.GetAttribute("genre")=="fantasy")
      {
       xe.RemoveAttribute("genre");//删除genre属性
       }
      else if(xe.GetAttribute("genre")=="update李赞红")
     {
      xe.RemoveAll();//删除该节点的全部内容
      }
    }
    xmlDoc.Save("bookstore.xml");

     //====================
最后结果为：

  <?xml version="1.0" encoding="gb2312"?>
   <bookstore>
    <book ISBN="2-3631-4">
      <title>Oberon's Legacy</title>
      <author>Corets, Eva</author>
      <price>5.95</price>
    </book>
    <book>
    </book>
  </bookstore>

  、显示所有数据。

  XmlNode xn=xmlDoc.SelectSingleNode("bookstore");
     XmlNodeList xnl=xn.ChildNodes;
     foreach(XmlNode xnf in xnl)
     {
      XmlElement xe=(XmlElement)xnf;
      Console.WriteLine(xe.GetAttribute("genre"));//显示属性值
       Console.WriteLine(xe.GetAttribute("ISBN"));
      XmlNodeList xnf1=xe.ChildNodes;
      foreach(XmlNode xn2 in xnf1)
     {
      Console.WriteLine(xn2.InnerText);//显示子节点点文本
      }
    }

转载：http://blog.****.net/s98/archive/2004/10/17/140307.aspx
 

C#操作XML的类：xmlHelper例子

首先，看下这个XmlHelper类库的结构，如下图：

然后，在Vs中新建一个解决方案，叫做XMLHelper，添加一个C# 类库项目XMLHelper，重命名Class1.cs为XmlHelper.cs。
再为XmlHelper.cs添加
using System.Collections;
using System.Xml;
这两个引用保证了我们可以使用XML的大部分功能和哈希表.
主要的代码如下：

C#代码  

 namespace XMLHelper
 {
     public class XmlHelper
     {
         #region 公共变量
         XmlDocument xmldoc;
         XmlNode xmlnode;
         XmlElement xmlelem;
         #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
             {
                 xmldoc = new XmlDocument();
                 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;
                 throw new Exception(e.Message);
             }
         }  

         #endregion  

         #region 常用操作方法(增删改)
         /// <summary>
         /// 插入一个节点和它的若干子节点
         /// </summary>
         /// <param name="XmlFile">Xml文件路径</param>
         /// <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 XmlFile, string NewNodeName, bool HasAttributes, string fatherNode, Hashtable htAtt, Hashtable htSubNode)
         {
             try
             {
                 xmldoc = new XmlDocument();
                 xmldoc.Load(XmlFile);
                 XmlNode root = xmldoc.SelectSingleNode(fatherNode);
                 xmlelem = xmldoc.CreateElement(NewNodeName);  

                 if (htAtt != null && HasAttributes)//若此节点有属性，则先添加属性
                 {
                     SetAttributes(xmlelem, htAtt);  

                     SetNodes(xmlelem.Name, xmldoc, xmlelem, htSubNode);//添加完此节点属性后，再添加它的子节点和它们的InnerText  

                 }
                 else
                 {
                     SetNodes(xmlelem.Name, xmldoc, xmlelem, htSubNode);//若此节点无属性，那么直接添加它的子节点
                 }  

                 root.AppendChild(xmlelem);
                 xmldoc.Save(XmlFile);  

                 return true;
             }
             catch (Exception e)
             {  

                 throw new Exception(e.Message);  

             }
         }
         /// <summary>
         /// 更新节点
         /// </summary>
         /// <param name="XmlFile">Xml文件路径</param>
         /// <param name="fatherNode">需要更新节点的上级节点</param>
         /// <param name="htAtt">需要更新的属性表，Key代表需要更新的属性，Value代表更新后的值</param>
         /// <param name="htSubNode">需要更新的子节点的属性表，Key代表需要更新的子节点名字Name,Value代表更新后的值InnerText</param>
         /// <returns>返回真为更新成功，否则失败</returns>
         public bool UpdateNode(string XmlFile, string fatherNode, Hashtable htAtt, Hashtable htSubNode)
         {
             try
             {
                 xmldoc = new XmlDocument();
                 xmldoc.Load(XmlFile);
                 XmlNodeList root = xmldoc.SelectSingleNode(fatherNode).ChildNodes;
                 UpdateNodes(root, htAtt, htSubNode);
                 xmldoc.Save(XmlFile);
                 return true;
             }
             catch (Exception e)
             {
                 throw new Exception(e.Message);
             }
         }  

         /// <summary>
         /// 删除指定节点下的子节点
         /// </summary>
         /// <param name="XmlFile">Xml文件路径</param>
         /// <param name="fatherNode">制定节点</param>
         /// <returns>返回真为更新成功，否则失败</returns>
         public bool DeleteNodes(string XmlFile, string fatherNode)
         {
             try
             {
                 xmldoc = new XmlDocument();
                 xmldoc.Load(XmlFile);
                 xmlnode = xmldoc.SelectSingleNode(fatherNode);
                 xmlnode.RemoveAll();
                 xmldoc.Save(XmlFile);
                 return true;
             }
             catch (XmlException xe)
             {
                 throw new XmlException(xe.Message);
             }
         }
         #endregion  

         #region 私有方法
         /// <summary>
         /// 设置节点属性
         /// </summary>
         /// <param name="xe">节点所处的Element</param>
         /// <param name="htAttribute">节点属性，Key代表属性名称，Value代表属性值</param>
         private void SetAttributes(XmlElement xe, Hashtable htAttribute)
         {
             foreach (DictionaryEntry de in htAttribute)
             {
                 xe.SetAttribute(de.Key.ToString(), de.Value.ToString());
             }
         }
         /// <summary>
         /// 增加子节点到根节点下
         /// </summary>
         /// <param name="rootNode">上级节点名称</param>
         /// <param name="XmlDoc">Xml文档</param>
         /// <param name="rootXe">父根节点所属的Element</param>
         /// <param name="SubNodes">子节点属性，Key为Name值，Value为InnerText值</param>
         private void SetNodes(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);
             }
         }
         /// <summary>
         /// 更新节点属性和子节点InnerText值
         /// </summary>
         /// <param name="root">根节点名字</param>
         /// <param name="htAtt">需要更改的属性名称和值</param>
         /// <param name="htSubNode">需要更改InnerText的子节点名字和值</param>
         private 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
     }
 }  

 文章来自学IT网：http://www.xueit.com/html/2009-08/21_4275_00.html
下面讲解此类：
、插入节点函数中的两个哈希表说明：
a.htAtt：用于存储了节点属性的哈希表，表中的Key对应了节点的属性名称，如<Fan Nickname="Jacky">这里的Nickname就是哈希表中的Key值，而Jacky就对应哈希表中的Value值，这样，你可以在插入节点前，把该节点的属性（多个）名称和对应的值先存入哈希表中，然后再传给函数即可增加多个属性。
b.htSubNode：存储了子节点的数据，子节点包括他的名字和InnerText值，如<Age></Age>这里的Age就是子节点名字，23就是节点的InnerText值。
、修改节点函数中的哈希表说明：
a.htAtt：存储了待更新的属性值，传入函数后，函数将逐一对比，查看节点中是否含有htAtt的Key值，如果含有，则表明节点的该属性的值(Value)将被htAtt中相应的Value替换。
b.htSubNode：存储了子节点的修改信息，传入函数后，函数将逐一对比，查看子节点的节点名字是否含有htSubNode的Key值，如果含有，则表明此子节点需要被更新，则此节点的InnerText将被修改为相应的htSubNode的Value值。
好了，下面我们来看看类库运行起来的效果吧：
一、先创建Xml文件，如下：

我们来这个路径下，打开刚才创建的xml文档，内容如下：
Xml代码  

 <a href="http://www.xueit.com/cshare/show-4275-2.aspx"><?xml version="1.0" encoding="utf-8"?>
 <AppSettings/></a>  

二、执行插入节点操作，如下图：（插入的节点数据在程序中，请稍候在本文尾部下载）
我们再打开这个文件，看看插入效果和程序中的一样么：
Xml代码  

 <?xml version="1.0" encoding="utf-8"?>
 <AppSettings>
   <Fan Nickname="Jacky">
     <Age></Age>
   </Fan>
 </AppSettings>  

三、我们修改一下节点内容：

修改效果如下：
Xml代码  

 <?xml version="1.0" encoding="utf-8"?>
 <AppSettings>
   <Fan Nickname="Doggy">
     <Age></Age>
   </Fan>
 </AppSettings>  

四、好了，删除刚才的那些节点吧：

又变回原样了：

Xml代码  

 <?xml version="1.0" encoding="utf-8"?>
 <AppSettings/>  

OK,这就是这个Helper的主要功能，你可以重载一些函数，增加它的功能，让它更加健壮，这回我就多了个帮手了，呵呵，可以根据自己需求更改，以后就不怕写Xml了，当然，你也可以把它移植到移动项目中，同样可行，只是到时候请注意路径问题，最好使用绝对路径！

文章来自学IT网：http://www.xueit.com/cshare/show-4275-2.aspx

Linq To Xml学习 － 3.查询、更新、删除

文章最后有该示例的XML文档。
查找具有特定属性的元素
XElement root = XElement.Load("PurchaseOrder.xml");
IEnumerable address =
    from el in root.Elements("Address")
    where (string)el.Attribute("Type") == "Billing"
    select el;
foreach (XElement el in address)
    Console.WriteLine(el);
输出为：
<Address Type="Billing">
  <Name>Tai YeeName>
  <Street> Oak AvenueStreet>
  <City>Old TownCity>
  <State>PAState>
  <Zip>95819Zip>
  <Country>USACountry>
Address>
内存中 XML 树修改与函数构造
就地修改 XML 树是更改 XML 文档形状的传统方法。 典型的应用程序将文档加载到数据存储区（如 DOM 或 LINQ to XML）；使用编程接口插入节点、删除节点或更改节点的内容；然后将 XML 保存到文件或通过网络传输。
LINQ to XML 允许使用另一种可在许多方案中使用的方法：函数构造。 函数构造将修改数据视为转换问题，而不是数据存储区的具体操作。 如果您采用某种数据表示形式并有效地将其从一种形式转换为另一种形式，其结果等效于您采用一个数据存储区并对其以某种方式进行操作以采用另一种形状。 函数构造方法的关键是将查询的结果传递给 XDocument 和 XElement 构造函数。
此示例假设您想修改下面的简单 XML 文档，使属性变为元素。 本节首先介绍传统的就地修改方法。 然后显示函数构造方法。XML文件：
xml version="1.0" encoding="utf-8" ?>
<Root Data1="" Data2="">
  <Child1>ContentChild1>
Root>
您可以编写一些过程代码以便从属性创建元素，然后删除属性，如下所示：
XElement root = XElement.Load("Data.xml");
foreach (XAttribute att in root.Attributes()) {
    root.Add(new XElement(att.Name, (string)att));
}
root.Attributes().Remove();
Console.WriteLine(root);
输出结果为：
<Root>
  <Child1>ContentChild1>
  <Data1>123Data1>
  <Data2>456Data2>
Root>

函数构造方法
相比之下，函数方法包含用于形成新树的代码、从源树中选择元素和属性并在将其添加到新树中时进行相应的转换。 函
数方法如下所示：
XElement root = XElement.Load("Data.xml");
XElement newTree = new XElement("Root",
    root.Element("Child1"),
    from att in root.Attributes()
    select new XElement(att.Name, (string)att)
);
Console.WriteLine(newTree);

在本例中，函数示例一点也不比第一个示例简短，而且一点也不比第一个示例简单。 但如果要对一个 XML 树进行很多
更改，则非函数方法将变得非常复杂，而且会显得很笨拙。 相比之下，使用函数方法时，您只需形成所需的 XML，嵌
入适当的查询和表达式以提取需要的内容。 函数方法生成的代码更易于维护。

请注意，在本例中，函数方法的执行效果可能没有树操作方法好。 主要问题是函数方法创建了更多短生存期的对象。
但是，如果使用函数方法能够提高程序员的效率，则折中也是一种有效的方式。

这是一个很简单的示例，但它显示了这两种方法之间基本原理上的差异。 对于转换较大的 XML 文档，函数方法可以产
生更高的效率增益。

向 XML 树中添加元素、属性和节点

下面的方法将子内容添加到 XElement 或 XDocument 中：

方法                 说明

Add                  在 XContainer 的子内容的末尾添加内容。

AddFirst           在 XContainer 的子内容的开头添加内容。

下面的方法将内容添加为 XNode 的同级节点。 向其中添加同级内容的最常见的节点是 XElement，不过你也可以将有
效的同级内容添加到其他类型的节点，例如 XText 或 XComment。

方法                         说明

AddAfterSelf            在 XNode 后面添加内容。

AddBeforeSelf          在 XNode 前面添加内容。

示例：

XElement srcTree = new XElement("Root",
    new XElement("Element1", ),
    new XElement("Element2", ),
    new XElement("Element3", ),
    new XElement("Element4", ),
    new XElement("Element5", )
);
XElement xmlTree = new XElement("Root",
    new XElement("Child1", ),
    new XElement("Child2", ),
    new XElement("Child3", ),
    new XElement("Child4", ),
    new XElement("Child5", )
);
xmlTree.Add(new XElement("NewChild", "new content"));
xmlTree.Add(
    from el in srcTree.Elements()
    where (int)el >
    select el
);
// Even though Child9 does not exist in srcTree, the following statement will not
// throw an exception, and nothing will be added to xmlTree.
xmlTree.Add(srcTree.Element("Child9"));
Console.WriteLine(xmlTree);

输出结果：

<Root>
  <Child1>1Child1>
  <Child2>2Child2>
  <Child3>3Child3>
  <Child4>4Child4>
  <Child5>5Child5>
  <NewChild>new contentNewChild>
  <Element4>4Element4>
  <Element5>5Element5>
Root>

修改 XML 树中的元素、属性和节点

下表汇总了修改元素、元素的子元素或元素属性 (Attribute) 时可以使用的方法和属性 (Property)。

下面的方法修改 XElement。

方法 说明
XElement..::.Parse 用已分析的 XML 替换元素。
XElement..::.RemoveAll 移除元素的所有内容（子节点和属性）。
XElement..::.RemoveAttributes 移除元素的属性。
XElement..::.ReplaceAll 替换元素的所有内容（子节点和属性）。
XElement..::.ReplaceAttributes 替换元素的属性。
XElement..::.SetAttributeValue 设置属性的值。 如果该属性不存在，则创建该属性。 如果值设置为 null，则移除该属性。
XElement..::.SetElementValue 设置子元素的值。 如果该元素不存在，则创建该元素。 如果值设置为 null，则移除该元素。
XElement..::.Value 用指定的文本替换元素的内容（子节点）。
XElement..::.SetValue 设置元素的值。

下面的方法修改 XAttribute。

方法 说明
XAttribute..::.Value 设置属性的值。
XAttribute..::.SetValue 设置属性的值。

下面的方法修改 XNode（包括 XElement 或 XDocument）。

方法 说明
XNode..::.ReplaceWith 用新内容替换节点。

下面的方法修改 XContainer（XElement 或 XDocument）。

方法 说明
XContainer..::.ReplaceNodes 用新内容替换子节点。

 XElement.SetElementValue 方法

此方法旨在简化将名称/值对列表用作子元素集时的维护。维护列表时，需要添加对、修改对或删除对。
如果调用此方法将不存在的名称作为子元素传递，则此方法会为您创建一个子元素。如果您调用此方
法来传递一个现有子元素的名称，则此方法会将此子元素的值更改为指定的值。如果您为 value 传递
了 nullNothingnullptrnull 引用（在 Visual Basic 中为 Nothing），则此方法会移除子元素。

// Create an element with no content
XElement root = new XElement("Root");

// Add some name/value pairs.
root.SetElementValue("Ele1", );
root.SetElementValue("Ele2", );
root.SetElementValue("Ele3", );
Console.WriteLine(root);

// Modify one of the name/value pairs.
root.SetElementValue("Ele2", );
Console.WriteLine(root);

// Remove one of the name/value pairs.
root.SetElementValue("Ele3", null);
Console.WriteLine(root);

输出结果：

<Root>
  <Ele1>1Ele1>
  <Ele2>2Ele2>
  <Ele3>3Ele3>
Root>
<Root>
  <Ele1>1Ele1>
  <Ele2>22Ele2>
  <Ele3>3Ele3>
Root>
<Root>
  <Ele1>1Ele1>
  <Ele2>22Ele2>
Root>

XElement.SetAttributeValue 方法

此方法旨在简化将名称/值对列表用作属性集时的维护。维护列表时，需要添加对、修改对或删除对。
如果调用此方法将不存在的名称作为属性传递，则此方法会为您创建一个属性。如果调用此方法来传递
现有属性的名称，则此方法将会属性的值修改为指定的值。如果您为 value 传递了
nullNothingnullptrnull 引用（在 Visual Basic 中为 Nothing），则此方法会移除该属性。

此方法将引发 Changed 和 Changing 事件。

将值分配给具有指定名称的属性。如果不存在具有指定名称的属性，则添加新属性。如果值为
nullNothingnullptrnull 引用（在 Visual Basic 中为 Nothing），则删除具有指定名称的属
性（如果存在）。

// Create an element with no content.
XElement root = new XElement("Root");

// Add some name/value pairs.
root.SetAttributeValue("Att1", );
root.SetAttributeValue("Att2", );
root.SetAttributeValue("Att3", );
Console.WriteLine(root);

// Modify one of the name/value pairs.
root.SetAttributeValue("Att2", );
Console.WriteLine(root);

// Remove one of the name/value pairs.
root.SetAttributeValue("Att3", null);
Console.WriteLine(root);

输出结果为：

<Root Att1="" Att2="" Att3="" />
<Root Att1="" Att2="" Att3="" />
<Root Att1="" Att2="" />

XNode.ReplaceWith 方法
使用指定的内容替换此节点。
XElement xmlTree = new XElement("Root",
    new XElement("Child1", "child1 content"),
    new XElement("Child2", "child2 content"),
    new XElement("Child3", "child3 content"),
    new XElement("Child4", "child4 content"),
    new XElement("Child5", "child5 content")
);
XElement child3 = xmlTree.Element("Child3");
child3.ReplaceWith(
    new XElement("NewChild", "new content")
);
Console.WriteLine(xmlTree);

输出结果：

<Root>
  <Child1>child1 contentChild1>
  <Child2>child2 contentChild2>
  <NewChild>new contentNewChild>
  <Child4>child4 contentChild4>
  <Child5>child5 contentChild5>
Root>

从 XML 树中移除元素、属性和节点

可以修改 XML 树，移除元素、属性和其他类型的节点。

从 XML 文档中移除单个元素或单个属性的操作非常简单。 但是，若要移除多个元素或属性的集合，则
应首先将一个集合具体化为一个列表，然后从该列表中删除相应元素或属性。 最好的方法是使用
Remove 扩展方法，该方法可以实现此操作。

这么做的主要原因在于，从 XML 树检索的大多数集合都是用延迟执行生成的。 如果不首先将集合具体
化为列表，或者不使用扩展方法，则可能会遇到某类 Bug。

示例：

此示例演示三种移除元素的方法。 第一种，移除单个元素。 第二种，检索元素的集合，使用
Enumerable.ToList<(Of <(TSource>)>) 运算符将它们具体化，然后移除集合。 最后一种，检索
元素的集合，使用 Remove 扩展方法移除元素。

XElement root = XElement.Parse(@"
");
root.Element("Child1").Element("GrandChild1").Remove();
root.Element("Child2").Elements().ToList().Remove();
root.Element("Child3").Elements().Remove();
Console.WriteLine(root);

输出结果为：

<Root>
  <Child1>
    <GrandChild2 />
    <GrandChild3 />
  Child1>
  <Child2 />
  <Child3 />
Root>
 

c# xml操作类

引子http://www.cnblogs.com/QDuck/archive/2007/01/10/617240.aspx

public class XmlControl
 {
  protected string strXmlFile;
  protected XmlDocument objXmlDoc = new XmlDocument();

  public XmlControl(string XmlFile)
  {
   //
   // TODO: 在這裡加入建構函式的程式碼
   //
   try
   {
    objXmlDoc.Load(XmlFile);
   }
   catch (System.Exception ex)
   {
    throw ex;
   }
   strXmlFile = XmlFile;
  }
  public DataView GetData(string XmlPathNode)
  {
   //查找數據。返回一個DataView
   DataSet ds = new DataSet();
   StringReader read = new StringReader(objXmlDoc.SelectSingleNode(XmlPathNode).OuterXml);
   ds.ReadXml(read);
   return ds.Tables[].DefaultView;
  }
  public void Replace(string XmlPathNode,string Content)
  {
   //更新節點內容。
   objXmlDoc.SelectSingleNode(XmlPathNode).InnerText = Content;
  }
  public void Delete(string Node)
  {
   //刪除一個節點。
   string mainNode = Node.Substring(,Node.LastIndexOf("/"));
   objXmlDoc.SelectSingleNode(mainNode).RemoveChild(objXmlDoc.SelectSingleNode(Node));
  }
  public void InsertNode(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);
  }
  public void InsertElement(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);
  }
  public void InsertElement(string MainNode,string Element,string Content)
  {
   //插入一個節點，不帶屬性。
   XmlNode objNode = objXmlDoc.SelectSingleNode(MainNode);
   XmlElement objElement = objXmlDoc.CreateElement(Element);
   objElement.InnerText = Content;
   objNode.AppendChild(objElement);
  }
  public void Save()
  {
   //保存文檔。
   try
   {
    objXmlDoc.Save(strXmlFile);
   }
   catch (System.Exception ex)
   {
    throw ex;
   }
   objXmlDoc = null;
  }
 }
=========================================================
实例应用：
   string strXmlFile = Server.MapPath("TestXml.xml");
   XmlControl xmlTool = new XmlControl(strXmlFile);
//   數據顯視
//   dgList.DataSource = xmlTool.GetData("Book/Authors[ISBN=\"0002\"]");
//   dgList.DataBind();
//   更新元素內容
//   xmlTool.Replace("Book/Authors[ISBN=\"0002\"]/Content","ppppppp");
//   xmlTool.Save();
//   添加一個新節點
//   xmlTool.InsertNode("Book","Author","ISBN","0004");
//   xmlTool.InsertElement("Book/Author[ISBN=\"0004\"]","Content","aaaaaaaaa");
//   xmlTool.InsertElement("Book/Author[ISBN=\"0004\"]","Title","Sex","man","iiiiiiii");
//   xmlTool.Save();
//   刪除一個指定節點的所有內容和屬性
//   xmlTool.Delete("Book/Author[ISBN=\"0004\"]");
//   xmlTool.Save();
//   刪除一個指定節點的子節點
//   xmlTool.Delete("Book/Authors[ISBN=\"0003\"]");
//   xmlTool.Save();

<％

Class XMLDOMDocument

Private fNode,fANode

Private fErrInfo,fFileName,fOpen

Dim XmlDom

'返回节点的缩进字串

Private Property Get TabStr(byVal Node)

TabStr=""

If Node Is Nothing Then Exit Property

If not Node.parentNode Is nothing Then TabStr=" "&TabStr(Node.parentNode)

End Property

'返回一个子节点对象,ElementOBJ为父节点,ChildNodeObj要查找的节点,IsAttributeNode指出是否为属性对象

Public Property Get ChildNode(byVal ElementOBJ,byVal ChildNodeObj,byVal IsAttributeNode)

Dim Element

Set ChildNode=Nothing

If IsNull(ChildNodeObj) Then

If IsAttributeNode=false Then

Set ChildNode=fNode

Else

Set ChildNode=fANode

End If

Exit Property

ElseIf IsObject(ChildNodeObj) Then

Set ChildNode=ChildNodeObj

Exit Property

End If

Set Element=Nothing

If LCase(TypeName(ChildNodeObj))="string" and Trim(ChildNodeObj)<>"" Then

If IsNull(ElementOBJ) Then

Set Element=fNode

ElseIf LCase(TypeName(ElementOBJ))="string" Then

If Trim(ElementOBJ)<>"" Then

Set Element=XmlDom.selectSingleNode("//"&Trim(ElementOBJ))

If Lcase(Element.nodeTypeString)="attribute" Then Set Element=Element.selectSingleNode("..")

End If

ElseIf IsObject(ElementOBJ) Then

Set Element=ElementOBJ

End If

If Element Is Nothing Then

Set ChildNode=XmlDom.selectSingleNode("//"&Trim(ChildNodeObj))

ElseIf IsAttributeNode=true Then

Set ChildNode=Element.selectSingleNode("./@"&Trim(ChildNodeObj))

Else

Set ChildNode=Element.selectSingleNode("./"&Trim(ChildNodeObj))

End If

End If

End Property

'读取最后的错误信息

Public Property Get ErrInfo

ErrInfo=fErrInfo

End Property

'给xml内容

Public Property Get xmlText(byVal ElementOBJ)

xmlText=""

If fopen=false Then Exit Property

Set ElementOBJ=ChildNode(XmlDom,ElementOBJ,false)

If ElementOBJ Is Nothing Then Set ElementOBJ=XmlDom

xmlText=ElementOBJ.xml

End Property

'=================================================================

'类初始化

Private Sub Class_Initialize()

Set XmlDom=CreateObject("Microsoft.XMLDOM")

XmlDom.preserveWhiteSpace=true

Set fNode=Nothing

Set fANode=Nothing

fErrInfo=""

fFileName=""

fopen=false

End Sub

'类释放

Private Sub Class_Terminate()

Set fNode=Nothing

Set fANode=Nothing

Set XmlDom=nothing

fopen=false

End Sub

'=====================================================================

'建立一个XML文件，RootElementName：根结点名。XSLURL：使用XSL样式地址

'返回根结点

Function Create(byVal RootElementName,byVal XslUrl)

Dim PINode,RootElement

Set Create=Nothing

If (XmlDom Is Nothing) Or (fopen=true) Then Exit Function

If Trim(RootElementName)="" Then RootElementName="Root"

Set PINode=XmlDom.CreateProcessingInstruction("xml", "version=""1.0"" encoding=""GB2312""")

XmlDom.appendChild PINode

Set PINode=XMLDOM.CreateProcessingInstruction("xml-stylesheet", "type=""text/xsl"" href="""&XslUrl&"""")

XmlDom.appendChild PINode

Set RootElement=XmlDom.createElement(Trim(RootElementName))

XmlDom.appendChild RootElement

Set Create=RootElement

fopen=True

set fNode=RootElement

End Function

'开打一个已经存在的XML文件,返回打开状态

Function Open(byVal xmlSourceFile)

Open=false

xmlSourceFile=Trim(xmlSourceFile)

If xmlSourceFile="" Then Exit Function

XmlDom.async = false

XmlDom.load xmlSourceFile

fFileName=xmlSourceFile

If not IsError Then

Open=true

fopen=true

End If

End Function

'关闭

Sub Close()

Set fNode=Nothing

Set fANode=Nothing

fErrInfo=""

fFileName=""

fopen=false

End Sub

'读取一个NodeOBJ的节点Text的值

'NodeOBJ可以是节点对象或节点名，为null就取当前默认fNode

Function getNodeText(byVal NodeOBJ)

getNodeText=""

If fopen=false Then Exit Function

Set NodeOBJ=ChildNode(null,NodeOBJ,false)

If NodeOBJ Is Nothing Then Exit Function

If Lcase(NodeOBJ.nodeTypeString)="element" Then

set fNode=NodeOBJ

Else

set fANode=NodeOBJ

End If

getNodeText=NodeOBJ.text

End function

'插入在BefelementOBJ下面一个名为ElementName，Value为ElementText的子节点。

'IsFirst：是否插在第一个位置；IsCDATA：说明节点的值是否属于CDATA类型

'插入成功就返回新插入这个节点

'BefelementOBJ可以是对象也可以是节点名，为null就取当前默认对象

Function InsertElement(byVal BefelementOBJ,byVal ElementName,byVal ElementText,byVal IsFirst,byVal IsCDATA)

Dim Element,TextSection,SpaceStr

Set InsertElement=Nothing

If not fopen Then Exit Function

Set BefelementOBJ=ChildNode(XmlDom,BefelementOBJ,false)

If BefelementOBJ Is Nothing Then Exit Function

Set Element=XmlDom.CreateElement(Trim(ElementName))

'SpaceStr=vbCrLf&TabStr(BefelementOBJ)

'Set STabStr=XmlDom.CreateTextNode(SpaceStr)

'If Len(SpaceStr)>2 Then SpaceStr=Left(SpaceStr,Len(SpaceStr)-2)

'Set ETabStr=XmlDom.CreateTextNode(SpaceStr)

If IsFirst=true Then

'BefelementOBJ.InsertBefore ETabStr,BefelementOBJ.firstchild

BefelementOBJ.InsertBefore Element,BefelementOBJ.firstchild

'BefelementOBJ.InsertBefore STabStr,BefelementOBJ.firstchild

Else

'BefelementOBJ.appendChild STabStr

BefelementOBJ.appendChild Element

'BefelementOBJ.appendChild ETabStr

End If

If IsCDATA=true Then

set TextSection=XmlDom.createCDATASection(ElementText)

Element.appendChild TextSection

ElseIf ElementText<>"" Then

Element.Text=ElementText

End If

Set InsertElement=Element

Set fNode=Element

End Function

'在ElementOBJ节点上插入或修改名为AttributeName，值为：AttributeText的属性

'如果已经存在名为AttributeName的属性对象，就进行修改。

'返回插入或修改属性的Node

'ElementOBJ可以是Element对象或名，为null就取当前默认对象

Function setAttributeNode(byVal ElementOBJ,byVal AttributeName,byVal AttributeText)

Dim AttributeNode

Set setAttributeNode=nothing

If not fopen Then Exit Function

Set ElementOBJ=ChildNode(XmlDom,ElementOBJ,false)

If ElementOBJ Is Nothing Then Exit Function

Set AttributeNode=ElementOBJ.attributes.getNamedItem(AttributeName)

If AttributeNode Is nothing Then

Set AttributeNode=XmlDom.CreateAttribute(AttributeName)

ElementOBJ.setAttributeNode AttributeNode

End If

AttributeNode.text=AttributeText

set fNode=ElementOBJ

set fANode=AttributeNode

Set setAttributeNode=AttributeNode

End Function

'修改ElementOBJ节点的Text值，并返回这个节点

'ElementOBJ可以对象或对象名，为null就取当前默认对象

Function UpdateNodeText(byVal ElementOBJ,byVal NewElementText,byVal IsCDATA)

Dim TextSection

set UpdateNodeText=nothing

If not fopen Then Exit Function

Set ElementOBJ=ChildNode(XmlDom,ElementOBJ,false)

If ElementOBJ Is Nothing Then Exit Function

If IsCDATA=true Then

set TextSection=XmlDom.createCDATASection(NewElementText)

If ElementOBJ.firstchild Is Nothing Then

ElementOBJ.appendChild TextSection

ElseIf LCase(ElementOBJ.firstchild.nodeTypeString)="cdatasection" Then

ElementOBJ.replaceChild TextSection,ElementOBJ.firstchild

End If

Else

ElementOBJ.Text=NewElementText

End If

set fNode=ElementOBJ

Set UpdateNodeText=ElementOBJ

End Function

'返回符合testValue条件的第一个ElementNode，为null就取当前默认对象

Function getElementNode(byVal ElementName,byVal testValue)

Dim Element,regEx,baseName

Set getElementNode=nothing

If not fopen Then Exit Function

testValue=Trim(testValue)

Set regEx=New RegExp

regEx.Pattern="^[A-Za-z]+"

regEx.IgnoreCase=true

If regEx.Test(testValue) Then testValue="/"&testValue

Set regEx=nothing

baseName=LCase(Right(ElementName,Len(ElementName)-InStrRev(ElementName,"/",-)))

Set Element=XmlDom.SelectSingleNode("//"&ElementName&testValue)

If Element Is Nothing Then

'Response.write ElementName&testValue

Set getElementNode=nothing

Exit Function

End If

Do While LCase(Element.baseName)<>baseName

Set Element=Element.selectSingleNode("..")

If Element Is Nothing Then Exit Do

Loop

If LCase(Element.baseName)<>baseName Then

Set getElementNode=nothing

Else

Set getElementNode=Element

If Lcase(Element.nodeTypeString)="element" Then

Set fNode=Element

Else

Set fANode=Element

End If

End If

End Function

'删除一个子节点

Function removeChild(byVal ElementOBJ)

removeChild=false

If not fopen Then Exit Function

Set ElementOBJ=ChildNode(null,ElementOBJ,false)

If ElementOBJ Is Nothing Then Exit Function

'response.write ElementOBJ.baseName

If Lcase(ElementOBJ.nodeTypeString)="element" Then

If ElementOBJ Is fNode Then set fNode=Nothing

If ElementOBJ.parentNode Is Nothing Then

XmlDom.removeChild(ElementOBJ)

Else

ElementOBJ.parentNode.removeChild(ElementOBJ)

End If

removeChild=True

End If

End Function

'清空一个节点所有子节点

Function ClearNode(byVal ElementOBJ)

set ClearNode=Nothing

If not fopen Then Exit Function

Set ElementOBJ=ChildNode(null,ElementOBJ,false)

If ElementOBJ Is Nothing Then Exit Function

ElementOBJ.text=""

ElementOBJ.removeChild(ElementOBJ.firstchild)

Set ClearNode=ElementOBJ

Set fNode=ElementOBJ

End Function

'删除子节点的一个属性

Function removeAttributeNode(byVal ElementOBJ,byVal AttributeOBJ)

removeAttributeNode=false

If not fopen Then Exit Function

Set ElementOBJ=ChildNode(XmlDom,ElementOBJ,false)

If ElementOBJ Is Nothing Then Exit Function

Set AttributeOBJ=ChildNode(ElementOBJ,AttributeOBJ,true)

If not AttributeOBJ Is nothing Then

c#读写xml文件

c#读写xml文件
已知有一个XML文件（bookstore.xml）如下：
<?xml version="1.0" encoding="gb2312"?>
<bookstore>
  <book genre="fantasy" ISBN="2-3631-4">
    <title>Oberon's Legacy</title>
    <author>Corets, Eva</author>
    <price>5.95</price>
  </book>
</bookstore>

、往<bookstore>节点中插入一个<book>节点：
   XmlDocument xmlDoc=new XmlDocument();
   xmlDoc.Load("bookstore.xml");
   XmlNode root=xmlDoc.SelectSingleNode("bookstore");//查找<bookstore>
   XmlElement xe1=xmlDoc.CreateElement("book");//创建一个<book>节点
   xe1.SetAttribute("genre","李赞红");//设置该节点genre属性
   xe1.SetAttribute("ISBN","2-3631-4");//设置该节点ISBN属性

   XmlElement xesub1=xmlDoc.CreateElement("title");
   xesub1.InnerText="CS从入门到精通";//设置文本节点
   xe1.AppendChild(xesub1);//添加到<book>节点中
   XmlElement xesub2=xmlDoc.CreateElement("author");
   xesub2.InnerText="候捷";
   xe1.AppendChild(xesub2);
   XmlElement xesub3=xmlDoc.CreateElement("price");
   xesub3.InnerText="58.3";
   xe1.AppendChild(xesub3);

   root.AppendChild(xe1);//添加到<bookstore>节点中
   xmlDoc.Save("bookstore.xml");
//===============================================
结果为：
<?xml version="1.0" encoding="gb2312"?>
<bookstore>
  <book genre="fantasy" ISBN="2-3631-4">
    <title>Oberon's Legacy</title>
    <author>Corets, Eva</author>
    <price>5.95</price>
  </book>
  <book genre="李赞红" ISBN="2-3631-4">
    <title>CS从入门到精通</title>
    <author>候捷</author>
    <price>58.3</price>
  </book>
</bookstore>

、修改节点：将genre属性值为“李赞红“的节点的genre值改为“update李赞红”，将该节点的子节点<author>的文本修改为“亚胜”。
    XmlNodeList nodeList=xmlDoc.SelectSingleNode("bookstore").ChildNodes;//获取bookstore节点的所有子节点
   foreach(XmlNode xn in nodeList)//遍历所有子节点
   {
    XmlElement xe=(XmlElement)xn;//将子节点类型转换为XmlElement类型
    if(xe.GetAttribute("genre")=="李赞红")//如果genre属性值为“李赞红”
    {
     xe.SetAttribute("genre","update李赞红");//则修改该属性为“update李赞红”

     XmlNodeList nls=xe.ChildNodes;//继续获取xe子节点的所有子节点
     foreach(XmlNode xn1 in nls)//遍历
     {
      XmlElement xe2=(XmlElement)xn1;//转换类型
      if(xe2.Name=="author")//如果找到
      {
       xe2.InnerText="亚胜";//则修改
       break;//找到退出来就可以了
      }
     }
     break;
    }
   }

   xmlDoc.Save("bookstore.xml");//保存。
//==================================================
最后结果为：
<?xml version="1.0" encoding="gb2312"?>
<bookstore>
  <book genre="fantasy" ISBN="2-3631-4">
    <title>Oberon's Legacy</title>
    <author>Corets, Eva</author>
    <price>5.95</price>
  </book>
  <book genre="update李赞红" ISBN="2-3631-4">
    <title>CS从入门到精通</title>
    <author>亚胜</author>
    <price>58.3</price>
  </book>
</bookstore>

、删除 <book genre="fantasy" ISBN="2-3631-4">节点的genre属性，删除 <book genre="update李赞红" ISBN="2-3631-4">节点。
XmlNodeList xnl=xmlDoc.SelectSingleNode("bookstore").ChildNodes;

   foreach(XmlNode xn in xnl)
   {
    XmlElement xe=(XmlElement)xn;
    if(xe.GetAttribute("genre")=="fantasy")
    {
     xe.RemoveAttribute("genre");//删除genre属性
    }
    else if(xe.GetAttribute("genre")=="update李赞红")
    {
     xe.RemoveAll();//删除该节点的全部内容
    }
   }
   xmlDoc.Save("bookstore.xml");
//===========================================
最后结果为：
<?xml version="1.0" encoding="gb2312"?>
<bookstore>
  <book ISBN="2-3631-4">
    <title>Oberon's Legacy</title>
    <author>Corets, Eva</author>
    <price>5.95</price>
  </book>
  <book>
  </book>
</bookstore>

、显示所有数据。
   XmlNode xn=xmlDoc.SelectSingleNode("bookstore");

   XmlNodeList xnl=xn.ChildNodes;

   foreach(XmlNode xnf in xnl)
   {
    XmlElement xe=(XmlElement)xnf;
    Console.WriteLine(xe.GetAttribute("genre"));//显示属性值
    Console.WriteLine(xe.GetAttribute("ISBN"));

    XmlNodeList xnf1=xe.ChildNodes;
    foreach(XmlNode xn2 in xnf1)
    {
     Console.WriteLine(xn2.InnerText);//显示子节点点文本
    }
   }

C#：XML操作类

写的一个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;
namespace PuTianCheng
{
    /// <summary>
    /// XmlHelper 的摘要说明
    /// </summary>
    public class XmlHelper
    {
        public XmlHelper()
        {
        }
        /// <summary>
        /// 读取数据
        /// </summary>
        /// <param name="path">路径</param>
        /// <param name="node">节点</param>
        /// <param name="attribute">属性名，非空时返回该属性值，否则返回串联值</param>
        /// <returns>string</returns>
        /**************************************************
         * 使用示列:
         * XmlHelper.Read(path, "/Node", "")
         * XmlHelper.Read(path, "/Node/Element[@Attribute='Name']", "Attribute")
         ************************************************/
        public static string Read(string path, string node, string attribute)
        {
            string value = "";
            try
            {
                XmlDocument doc = new XmlDocument();
                doc.Load(path);
                XmlNode xn = doc.SelectSingleNode(node);
                value = (attribute.Equals("") ? xn.InnerText : xn.Attributes[attribute].Value);
            }
            catch { }
            return value;
        }
        /// <summary>
        /// 插入数据
        /// </summary>
        /// <param name="path">路径</param>
        /// <param name="node">节点</param>
        /// <param name="element">元素名，非空时插入新元素，否则在该元素中插入属性</param>
        /// <param name="attribute">属性名，非空时插入该元素属性值，否则插入元素值</param>
        /// <param name="value">值</param>
        /// <returns></returns>
        /**************************************************
         * 使用示列:
         * XmlHelper.Insert(path, "/Node", "Element", "", "Value")
         * XmlHelper.Insert(path, "/Node", "Element", "Attribute", "Value")
         * XmlHelper.Insert(path, "/Node", "", "Attribute", "Value")
         ************************************************/
        public static void Insert(string path, string node, string element, string attribute, string value)
        {
            try
            {
                XmlDocument doc = new XmlDocument();
                doc.Load(path);
                XmlNode xn = doc.SelectSingleNode(node);
                if (element.Equals(""))
                {
                    if (!attribute.Equals(""))
                    {
                        XmlElement xe = (XmlElement)xn;
                        xe.SetAttribute(attribute, value);
                    }
                }
                else
                {
                    XmlElement xe = doc.CreateElement(element);
                    if (attribute.Equals(""))
                        xe.InnerText = value;
                    else
                        xe.SetAttribute(attribute, value);
                    xn.AppendChild(xe);
                }
                doc.Save(path);
            }
            catch { }
        }
        /// <summary>
        /// 修改数据
        /// </summary>
        /// <param name="path">路径</param>
        /// <param name="node">节点</param>
        /// <param name="attribute">属性名，非空时修改该节点属性值，否则修改节点值</param>
        /// <param name="value">值</param>
        /// <returns></returns>
        /**************************************************
         * 使用示列:
         * XmlHelper.Insert(path, "/Node", "", "Value")
         * XmlHelper.Insert(path, "/Node", "Attribute", "Value")
         ************************************************/
        public static void Update(string path, string node, string attribute, string value)
        {
            try
            {
                XmlDocument doc = new XmlDocument();
                doc.Load(path);
                XmlNode xn = doc.SelectSingleNode(node);
                XmlElement xe = (XmlElement)xn;
                if (attribute.Equals(""))
                    xe.InnerText = value;
                else
                    xe.SetAttribute(attribute, value);
                doc.Save(path);
            }
            catch { }
        }
        /// <summary>
        /// 删除数据
        /// </summary>
        /// <param name="path">路径</param>
        /// <param name="node">节点</param>
        /// <param name="attribute">属性名，非空时删除该节点属性值，否则删除节点值</param>
        /// <param name="value">值</param>
        /// <returns></returns>
        /**************************************************
         * 使用示列:
         * XmlHelper.Delete(path, "/Node", "")
         * XmlHelper.Delete(path, "/Node", "Attribute")
         ************************************************/
        public static void Delete(string path, string node, string attribute)
        {
            try
            {
                XmlDocument doc = new XmlDocument();
                doc.Load(path);
                XmlNode xn = doc.SelectSingleNode(node);
                XmlElement xe = (XmlElement)xn;
                if (attribute.Equals(""))
                    xn.ParentNode.RemoveChild(xn);
                else
                    xe.RemoveAttribute(attribute);
                doc.Save(path);
            }
            catch { }
        }
    }
}
==================================================
XmlFile.xml：
<?xml version="1.0" encoding="utf-8"?>
<Root />
==================================================
使用方法：
string xml = Server.MapPath("XmlFile.xml");
//插入元素
//XmlHelper.Insert(xml, "/Root", "Studio", "", "");
//插入元素/属性
//XmlHelper.Insert(xml, "/Root/Studio", "Site", "Name", "小路工作室");
//XmlHelper.Insert(xml, "/Root/Studio", "Site", "Name", "丁香鱼工作室");
//XmlHelper.Insert(xml, "/Root/Studio", "Site", "Name", "谱天城工作室");
//XmlHelper.Insert(xml, "/Root/Studio/Site[@Name='谱天城工作室']", "Master", "", "红尘静思");
//插入属性
//XmlHelper.Insert(xml, "/Root/Studio/Site[@Name='小路工作室']", "", "Url", "http://www.wzlu.com/");
//XmlHelper.Insert(xml, "/Root/Studio/Site[@Name='丁香鱼工作室']", "", "Url", "http://www.luckfish.net/");
//XmlHelper.Insert(xml, "/Root/Studio/Site[@Name='谱天城工作室']", "", "Url", "http://www.putiancheng.com/");
//修改元素值
//XmlHelper.Update(xml, "/Root/Studio/Site[@Name='谱天城工作室']/Master", "", "RedDust");
//修改属性值
//XmlHelper.Update(xml, "/Root/Studio/Site[@Name='谱天城工作室']", "Url", "http://www.putiancheng.net/");
//XmlHelper.Update(xml, "/Root/Studio/Site[@Name='谱天城工作室']", "Name", "PuTianCheng Studio");
//读取元素值
//Response.Write("<div>" + XmlHelper.Read(xml, "/Root/Studio/Site/Master", "") + "</div>");
//读取属性值
//Response.Write("<div>" + XmlHelper.Read(xml, "/Root/Studio/Site", "Url") + "</div>");
//读取特定属性值
//Response.Write("<div>" + XmlHelper.Read(xml, "/Root/Studio/Site[@Name='丁香鱼工作室']", "Url") + "</div>");
//删除属性
//XmlHelper.Delete(xml, "/Root/Studio/Site[@Name='小路工作室']", "Url");
//删除元素
//XmlHelper.Delete(xml, "/Root/Studio", "");