C#操作xml完整类文件

C#操作xml完整类文件

xml_oper.cs
using ...System;
using System.Data;
using System.Web;
using System.Xml;
/**//// 

/// 类名:xml操作类
/// 作者:虫
/// 时间:2008.8.31
/// 
public class xml_oper
...{
    private XmlDocument xmlDoc;  
public xml_oper()
...{
}
    /**//// 

    /// 加载xml文件
    /// 
    /// xml文件的物理路径
    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);
        }
    }
    /**//// 

    /// 添加xml子节点
    /// 
    /// xml文件的物理路径
    /// 根节点名称
    /// 添加的子节点名称
    /// 子节点文本
    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 > 0)
        ...{
            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文件
        }
    }
    /**//// 

    /// 修改节点的内容
    /// 
    /// xml文件的物理路径
    /// 根节点名称
    /// 节点的新内容
    /// 节点的属性名
    /// 节点的属性值
    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;
            }
        }
         
    }
    /**//// 

    /// 删除节点
    /// 
    /// xml文件的物理路径
    /// 根节点名称
    /// 节点的属性名
    /// 节点的属性值
    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;
            }
        }
    }
}
  

View Code

C#解析XML基础

(转) C#解析XML基础
  

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

1 "1.0" encoding="gb2312"?> 
2   
3   "fantasy" ISBN="2-3631-4"> 
4      
5     Corets, Eva 
6     5.95 
7    
8  

 
 1、往节点中插入一个节点：

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

 //================ 
 
结果为：

 1 "1.0" encoding="gb2312"?> 
 2   
 3   "fantasy" ISBN="2-3631-4"> 
 4      
 5     Corets, Eva 
 6     5.95 
 7    
 8   "李赞红" ISBN="2-3631-4"> 
 9      
10     候捷 
11     58.3 
12    
13  

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

 1 //获取bookstore节点的所有子节点
 2  XmlNodeList nodeList=xmlDoc.SelectSingleNode("bookstore").ChildNodes;
 3    foreach(XmlNode xn in nodeList)//遍历所有子节点
 4     {
 5     XmlElement xe=(XmlElement)xn;//将子节点类型转换为XmlElement类型
 6      if(xe.GetAttribute("genre")=="李赞红")//如果genre属性值为“李赞红”
 7      {
 8      xe.SetAttribute("genre","update李赞红");//则修改该属性为“update李赞红”
 9       XmlNodeList nls=xe.ChildNodes;//继续获取xe子节点的所有子节点
10       foreach(XmlNode xn1 in nls)//遍历
11       {
12       XmlElement xe2=(XmlElement)xn1;//转换类型
13        if(xe2.Name=="author")//如果找到
14        {
15        xe2.InnerText="亚胜";//则修改
16         break;//找到退出来就可以了
17        }
18      }
19      break;
20     }
21    }
22    xmlDoc.Save("bookstore.xml");//保存。

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

 1 "1.0" encoding="gb2312"?> 
 2   
 3   "fantasy" ISBN="2-3631-4"> 
 4      
 5     Corets, Eva 
 6     5.95 
 7    
 8   "update李赞红" ISBN="2-3631-4"> 
 9      
10     亚胜 
11     58.3 
12    
13  

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

 1 XmlNodeList xnl=xmlDoc.SelectSingleNode("bookstore").ChildNodes;
 2    foreach(XmlNode xn in xnl)
 3    {
 4     XmlElement xe=(XmlElement)xn;
 5  if(xe.GetAttribute("genre")=="fantasy")
 6     {
 7      xe.RemoveAttribute("genre");//删除genre属性
 8      }
 9     else if(xe.GetAttribute("genre")=="update李赞红")
10     {
11      xe.RemoveAll();//删除该节点的全部内容
12      }
13    }
14    xmlDoc.Save("bookstore.xml");

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

 1 "1.0" encoding="gb2312"?> 
 2   
 3   "2-3631-4"> 
 4      
 5     Corets, Eva 
 6     5.95 
 7    
 8    
 9    
10  

 
  4、显示所有数据。

 1 XmlNode xn=xmlDoc.SelectSingleNode("bookstore");
 2    XmlNodeList xnl=xn.ChildNodes;
 3    foreach(XmlNode xnf in xnl)
 4    {
 5     XmlElement xe=(XmlElement)xnf;
 6     Console.WriteLine(xe.GetAttribute("genre"));//显示属性值
 7      Console.WriteLine(xe.GetAttribute("ISBN"));
 8     XmlNodeList xnf1=xe.ChildNodes;
 9     foreach(XmlNode xn2 in xnf1)
10     {
11      Console.WriteLine(xn2.InnerText);//显示子节点点文本
12      }
13    }

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

View Code

C#操作XML的类：xmlHelper例子

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

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

 
C#代码  

1 namespace XMLHelper  
2 {  
3     public class XmlHelper  
4     {  
5         #region 公共变量  
6         XmlDocument xmldoc;  
7         XmlNode xmlnode;  
8         XmlElement xmlelem;  
9         #endregion  
10  
11         #region 创建Xml文档  
12         /// 
  
13         /// 创建一个带有根节点的Xml文件  
14         ///   
15         /// Xml文件名称  
16         /// 根节点名称  
17         /// 编码方式:gb2312，UTF-8等常见的  
18         /// 保存的目录路径  
19         ///   
20         public bool CreateXmlDocument(string FileName, string rootName, string Encode)  
21         {  
22             try  
23             {  
24                 xmldoc = new XmlDocument();  
25                 XmlDeclaration xmldecl;  
26                 xmldecl = xmldoc.CreateXmlDeclaration("1.0", Encode, null);  
27                 xmldoc.AppendChild(xmldecl);  
28                 xmlelem = xmldoc.CreateElement("", rootName, "");  
29                 xmldoc.AppendChild(xmlelem);  
30                 xmldoc.Save(FileName);  
31                 return true;  
32             }  
33             catch (Exception e)  
34             {  
35                 return false;  
36                 throw new Exception(e.Message);  
37             }  
38         }  
39  
40         #endregion  
41  
42         #region 常用操作方法(增删改)  
43         /// 
  
44         /// 插入一个节点和它的若干子节点  
45         ///   
46         /// Xml文件路径  
47         /// 插入的节点名称  
48         /// 此节点是否具有属性，True为有，False为无  
49         /// 此插入节点的父节点  
50         /// 此节点的属性，Key为属性名，Value为属性值  
51         /// 子节点的属性，Key为Name,Value为InnerText  
52         /// 返回真为更新成功，否则失败  
53         public bool InsertNode(string XmlFile, string NewNodeName, bool HasAttributes, string fatherNode, Hashtable htAtt, Hashtable htSubNode)  
54         {  
55             try  
56             {  
57                 xmldoc = new XmlDocument();  
58                 xmldoc.Load(XmlFile);  
59                 XmlNode root = xmldoc.SelectSingleNode(fatherNode);  
60                 xmlelem = xmldoc.CreateElement(NewNodeName);  
61   
62                 if (htAtt != null && HasAttributes)//若此节点有属性，则先添加属性  
63                 {  
64                     SetAttributes(xmlelem, htAtt);  
65   
66                     SetNodes(xmlelem.Name, xmldoc, xmlelem, htSubNode);//添加完此节点属性后，再添加它的子节点和它们的InnerText  
67   
68                 }  
69                 else  
70                 {  
71                     SetNodes(xmlelem.Name, xmldoc, xmlelem, htSubNode);//若此节点无属性，那么直接添加它的子节点  
72                 }  
73   
74                 root.AppendChild(xmlelem);  
75                 xmldoc.Save(XmlFile);  
76   
77                 return true;  
78             }  
79             catch (Exception e)  
80             {  
81   
82                 throw new Exception(e.Message);  
83   
84             }  
85         }  
86         /// 
  
87         /// 更新节点  
88         ///   
89         /// Xml文件路径  
90         /// 需要更新节点的上级节点  
91         /// 需要更新的属性表，Key代表需要更新的属性，Value代表更新后的值  
92         /// 需要更新的子节点的属性表，Key代表需要更新的子节点名字Name,Value代表更新后的值InnerText  
93         /// 返回真为更新成功，否则失败  
94         public bool UpdateNode(string XmlFile, string fatherNode, Hashtable htAtt, Hashtable htSubNode)  
95         {  
96             try  
97             {  
98                 xmldoc = new XmlDocument();  
99                 xmldoc.Load(XmlFile);  
100                 XmlNodeList root = xmldoc.SelectSingleNode(fatherNode).ChildNodes;  
101                 UpdateNodes(root, htAtt, htSubNode);  
102                 xmldoc.Save(XmlFile);  
103                 return true;  
104             }  
105             catch (Exception e)  
106             {  
107                 throw new Exception(e.Message);  
108             }  
109         }  
110   
111         /// 
  
112         /// 删除指定节点下的子节点  
113         ///   
114         /// Xml文件路径  
115         /// 制定节点  
116         /// 返回真为更新成功，否则失败  
117         public bool DeleteNodes(string XmlFile, string fatherNode)  
118         {  
119             try  
120             {  
121                 xmldoc = new XmlDocument();  
122                 xmldoc.Load(XmlFile);  
123                 xmlnode = xmldoc.SelectSingleNode(fatherNode);  
124                 xmlnode.RemoveAll();  
125                 xmldoc.Save(XmlFile);  
126                 return true;  
127             }  
128             catch (XmlException xe)  
129             {  
130                 throw new XmlException(xe.Message);  
131             }  
132         }  
133         #endregion  
134  
135         #region 私有方法  
136         /// 
  
137         /// 设置节点属性  
138         ///   
139         /// 节点所处的Element  
140         /// 节点属性，Key代表属性名称，Value代表属性值  
141         private void SetAttributes(XmlElement xe, Hashtable htAttribute)  
142         {  
143             foreach (DictionaryEntry de in htAttribute)  
144             {  
145                 xe.SetAttribute(de.Key.ToString(), de.Value.ToString());  
146             }  
147         }  
148         /// 
  
149         /// 增加子节点到根节点下  
150         ///   
151         /// 上级节点名称  
152         /// Xml文档  
153         /// 父根节点所属的Element  
154         /// 子节点属性，Key为Name值，Value为InnerText值  
155         private void SetNodes(string rootNode, XmlDocument XmlDoc, XmlElement rootXe, Hashtable SubNodes)  
156         {  
157             foreach (DictionaryEntry de in SubNodes)  
158             {  
159                 xmlnode = XmlDoc.SelectSingleNode(rootNode);  
160                 XmlElement subNode = XmlDoc.CreateElement(de.Key.ToString());  
161                 subNode.InnerText = de.Value.ToString();  
162                 rootXe.AppendChild(subNode);  
163             }  
164         }  
165         /// 
  
166         /// 更新节点属性和子节点InnerText值  
167         ///   
168         /// 根节点名字  
169         /// 需要更改的属性名称和值  
170         /// 需要更改InnerText的子节点名字和值  
171         private void UpdateNodes(XmlNodeList root, Hashtable htAtt, Hashtable htSubNode)  
172         {  
173             foreach (XmlNode xn in root)  
174             {  
175                 xmlelem = (XmlElement)xn;  
176                 if (xmlelem.HasAttributes)//如果节点如属性，则先更改它的属性  
177                 {  
178                     foreach (DictionaryEntry de in htAtt)//遍历属性哈希表  
179                     {  
180                         if (xmlelem.HasAttribute(de.Key.ToString()))//如果节点有需要更改的属性  
181                         {  
182                             xmlelem.SetAttribute(de.Key.ToString(), de.Value.ToString());//则把哈希表中相应的值Value赋给此属性Key  
183                         }  
184                     }  
185                 }  
186                 if (xmlelem.HasChildNodes)//如果有子节点，则修改其子节点的InnerText  
187                 {  
188                     XmlNodeList xnl = xmlelem.ChildNodes;  
189                     foreach (XmlNode xn1 in xnl)  
190                     {  
191                         XmlElement xe = (XmlElement)xn1;  
192                         foreach (DictionaryEntry de in htSubNode)  
193                         {  
194                             if (xe.Name == de.Key.ToString())//htSubNode中的key存储了需要更改的节点名称，  
195                             {  
196                                 xe.InnerText = de.Value.ToString();//htSubNode中的Value存储了Key节点更新后的数据  
197                             }  
198                         }  
199                     }  
200                 }  
201   
202             }  
203         }  
204         #endregion  
205     }  
206 }  
207   
208   
209 文章来自学IT网：http://www.xueit.com/html/2009-08/21_4275_00.html  
下面讲解此类：
1、插入节点函数中的两个哈希表说明：
a.htAtt：用于存储了节点属性的哈希表，表中的Key对应了节点的属性名称，如"Jacky">这里的Nickname就是哈希表中的Key值，而Jacky就对应哈希表中的Value值，这样，你可以在插入节点前，把该节点的属性（多个）名称和对应的值先存入哈希表中，然后再传给函数即可增加多个属性。
b.htSubNode：存储了子节点的数据，子节点包括他的名字和InnerText值，如23这里的Age就是子节点名字，23就是节点的InnerText值。
2、修改节点函数中的哈希表说明：
a.htAtt：存储了待更新的属性值，传入函数后，函数将逐一对比，查看节点中是否含有htAtt的Key值，如果含有，则表明节点的该属性的值(Value)将被htAtt中相应的Value替换。
b.htSubNode：存储了子节点的修改信息，传入函数后，函数将逐一对比，查看子节点的节点名字是否含有htSubNode的Key值，如果含有，则表明此子节点需要被更新，则此节点的InnerText将被修改为相应的htSubNode的Value值。
好了，下面我们来看看类库运行起来的效果吧：
一、先创建Xml文件，如下：
 
我们来这个路径下，打开刚才创建的xml文档，内容如下：
Xml代码  

210 "http://www.xueit.com/cshare/show-4275-2.aspx">"1.0" encoding="utf-8"?>  
211   
 
 
二、执行插入节点操作，如下图：（插入的节点数据在程序中，请稍候在本文尾部下载）
我们再打开这个文件，看看插入效果和程序中的一样么：
Xml代码  

212 "1.0" encoding="utf-8"?>  
213   
214   "Jacky">  
215     23  
216     
217   
 
三、我们修改一下节点内容：

 
修改效果如下：
Xml代码  

218 "1.0" encoding="utf-8"?>  
219   
220   "Doggy">  
221     3  
222     
223   
 
四、好了，删除刚才的那些节点吧：


又变回原样了：
 
Xml代码  

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

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

View Code

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);
输出为：
"Billing">
  Tai YeeName>
  8 Oak AvenueStreet>
  Old TownCity>
  PAState>
  95819Zip>
  USACountry>
Address>
内存中 XML 树修改与函数构造
就地修改 XML 树是更改 XML 文档形状的传统方法。 典型的应用程序将文档加载到数据存储区（如 DOM 或 LINQ to XML）；使用编程接口插入节点、删除节点或更改节点的内容；然后将 XML 保存到文件或通过网络传输。
LINQ to XML 允许使用另一种可在许多方案中使用的方法：函数构造。 函数构造将修改数据视为转换问题，而不是数据存储区的具体操作。 如果您采用某种数据表示形式并有效地将其从一种形式转换为另一种形式，其结果等效于您采用一个数据存储区并对其以某种方式进行操作以采用另一种形状。 函数构造方法的关键是将查询的结果传递给 XDocument 和 XElement 构造函数。
此示例假设您想修改下面的简单 XML 文档，使属性变为元素。 本节首先介绍传统的就地修改方法。 然后显示函数构造方法。XML文件：
xml version="1.0" encoding="utf-8" ?>
"123" Data2="456">
  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);
输出结果为：

  ContentChild1>
  123Data1>
  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", 1),
    new XElement("Element2", 2),
    new XElement("Element3", 3),
    new XElement("Element4", 4),
    new XElement("Element5", 5)
);
XElement xmlTree = new XElement("Root",
    new XElement("Child1", 1),
    new XElement("Child2", 2),
    new XElement("Child3", 3),
    new XElement("Child4", 4),
    new XElement("Child5", 5)
);
xmlTree.Add(new XElement("NewChild", "new content"));
xmlTree.Add(
    from el in srcTree.Elements()
    where (int)el > 3
    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);
 
输出结果：
 

  1Child1>
  2Child2>
  3Child3>
  4Child4>
  5Child5>
  new contentNewChild>
  4Element4>
  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", 1);
root.SetElementValue("Ele2", 2);
root.SetElementValue("Ele3", 3);
Console.WriteLine(root);
 
// Modify one of the name/value pairs.
root.SetElementValue("Ele2", 22);
Console.WriteLine(root);
 
// Remove one of the name/value pairs.
root.SetElementValue("Ele3", null);
Console.WriteLine(root);
 
输出结果：
 

  1Ele1>
  2Ele2>
  3Ele3>
Root>

  1Ele1>
  22Ele2>
  3Ele3>
Root>

  1Ele1>
  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", 1);
root.SetAttributeValue("Att2", 2);
root.SetAttributeValue("Att3", 3);
Console.WriteLine(root);
 
// Modify one of the name/value pairs.
root.SetAttributeValue("Att2", 22);
Console.WriteLine(root);
 
// Remove one of the name/value pairs.
root.SetAttributeValue("Att3", null);
Console.WriteLine(root);
 
输出结果为：
 
"1" Att2="2" Att3="3" />
"1" Att2="22" Att3="3" />
"1" Att2="22" />
 
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);
 
输出结果：
 

  child1 contentChild1>
  child2 contentChild2>
  new contentNewChild>
  child4 contentChild4>
  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);
 
输出结果为：
 

  
    
    
  Child1>
  
  
Root>
 

View Code

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[0].DefaultView;
  }
  public void Replace(string XmlPathNode,string Content)
  {
   //更新節點內容。
   objXmlDoc.SelectSingleNode(XmlPathNode).InnerText = Content;
  }
  public void Delete(string Node)
  {
   //刪除一個節點。
   string mainNode = Node.Substring(0,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();



  1

<％
  2

Class XMLDOMDocument
  3

Private fNode,fANode
  4

Private fErrInfo,fFileName,fOpen
  5

Dim XmlDom
  6


  7

'返回节点的缩进字串
  8

Private Property Get TabStr(byVal Node)
  9

TabStr=""
 10

If Node Is Nothing Then Exit Property
 11

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

End Property
 13


 14

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

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

Dim Element
 17

Set ChildNode=Nothing
 18


 19

If IsNull(ChildNodeObj) Then
 20

If IsAttributeNode=false Then
 21

Set ChildNode=fNode
 22

Else
 23

Set ChildNode=fANode
 24

End If
 25

Exit Property
 26

ElseIf IsObject(ChildNodeObj) Then
 27

Set ChildNode=ChildNodeObj
 28

Exit Property
 29

End If
 30


 31

Set Element=Nothing
 32

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

If IsNull(ElementOBJ) Then
 34

Set Element=fNode
 35

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

If Trim(ElementOBJ)<>"" Then
 37

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

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

End If
 40

ElseIf IsObject(ElementOBJ) Then
 41

Set Element=ElementOBJ
 42

End If
 43


 44

If Element Is Nothing Then
 45

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

ElseIf IsAttributeNode=true Then
 47

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

Else
 49

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

End If
 51

End If
 52

End Property
 53


 54

'读取最后的错误信息
 55

Public Property Get ErrInfo
 56

ErrInfo=fErrInfo
 57

End Property
 58


 59

'给xml内容
 60

Public Property Get xmlText(byVal ElementOBJ)
 61

xmlText=""
 62

If fopen=false Then Exit Property
 63


 64

Set ElementOBJ=ChildNode(XmlDom,ElementOBJ,false)
 65

If ElementOBJ Is Nothing Then Set ElementOBJ=XmlDom
 66


 67

xmlText=ElementOBJ.xml
 68

End Property
 69


 70

'=================================================================
 71

'类初始化
 72

Private Sub Class_Initialize()
 73

Set XmlDom=CreateObject("Microsoft.XMLDOM")
 74

XmlDom.preserveWhiteSpace=true
 75


 76

Set fNode=Nothing
 77

Set fANode=Nothing
 78


 79

fErrInfo=""
 80

fFileName=""
 81

fopen=false
 82

End Sub
 83


 84

'类释放
 85

Private Sub Class_Terminate()
 86

Set fNode=Nothing
 87

Set fANode=Nothing
 88

Set XmlDom=nothing
 89

fopen=false
 90

End Sub
 91


 92

'=====================================================================
 93

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

'返回根结点
 95

Function Create(byVal RootElementName,byVal XslUrl)
 96

Dim PINode,RootElement
 97


 98

Set Create=Nothing
 99


100

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


102

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


104

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

XmlDom.appendChild PINode
106


107

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

XmlDom.appendChild PINode
109


110

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

XmlDom.appendChild RootElement
112


113

Set Create=RootElement
114


115

fopen=True
116

set fNode=RootElement
117

End Function
118


119

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

Function Open(byVal xmlSourceFile)
121

Open=false
122


123

xmlSourceFile=Trim(xmlSourceFile)
124

If xmlSourceFile="" Then Exit Function
125


126

XmlDom.async = false
127

XmlDom.load xmlSourceFile
128


129

fFileName=xmlSourceFile
130


131

If not IsError Then
132

Open=true
133

fopen=true
134

End If
135

End Function
136


137

'关闭
138

Sub Close()
139

Set fNode=Nothing
140

Set fANode=Nothing
141


142

fErrInfo=""
143

fFileName=""
144

fopen=false
145

End Sub
146


147

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

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

Function getNodeText(byVal NodeOBJ)
150

getNodeText=""
151

If fopen=false Then Exit Function
152


153

Set NodeOBJ=ChildNode(null,NodeOBJ,false)
154

If NodeOBJ Is Nothing Then Exit Function
155


156

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

set fNode=NodeOBJ
158

Else
159

set fANode=NodeOBJ
160

End If
161

getNodeText=NodeOBJ.text
162

End function
163


164

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

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

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

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

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

Dim Element,TextSection,SpaceStr
170

Set InsertElement=Nothing
171


172

If not fopen Then Exit Function
173


174

Set BefelementOBJ=ChildNode(XmlDom,BefelementOBJ,false)
175

If BefelementOBJ Is Nothing Then Exit Function
176


177

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


179

'SpaceStr=vbCrLf&TabStr(BefelementOBJ)
180

'Set STabStr=XmlDom.CreateTextNode(SpaceStr)
181


182

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

'Set ETabStr=XmlDom.CreateTextNode(SpaceStr)
184


185

If IsFirst=true Then
186

'BefelementOBJ.InsertBefore ETabStr,BefelementOBJ.firstchild
187

BefelementOBJ.InsertBefore Element,BefelementOBJ.firstchild
188

'BefelementOBJ.InsertBefore STabStr,BefelementOBJ.firstchild
189

Else
190

'BefelementOBJ.appendChild STabStr
191

BefelementOBJ.appendChild Element
192

'BefelementOBJ.appendChild ETabStr
193

End If
194


195

If IsCDATA=true Then
196

set TextSection=XmlDom.createCDATASection(ElementText)
197

Element.appendChild TextSection
198

ElseIf ElementText<>"" Then
199

Element.Text=ElementText
200

End If
201


202

Set InsertElement=Element
203

Set fNode=Element
204

End Function
205


206

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

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

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

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

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

Dim AttributeNode
212

Set setAttributeNode=nothing
213


214

If not fopen Then Exit Function
215


216

Set ElementOBJ=ChildNode(XmlDom,ElementOBJ,false)
217

If ElementOBJ Is Nothing Then Exit Function
218


219

Set AttributeNode=ElementOBJ.attributes.getNamedItem(AttributeName)
220

If AttributeNode Is nothing Then
221

Set AttributeNode=XmlDom.CreateAttribute(AttributeName)
222

ElementOBJ.setAttributeNode AttributeNode
223

End If
224

AttributeNode.text=AttributeText
225


226

set fNode=ElementOBJ
227

set fANode=AttributeNode
228

Set setAttributeNode=AttributeNode
229

End Function
230


231

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

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

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

Dim TextSection
235


236

set UpdateNodeText=nothing
237

If not fopen Then Exit Function
238


239

Set ElementOBJ=ChildNode(XmlDom,ElementOBJ,false)
240

If ElementOBJ Is Nothing Then Exit Function
241


242

If IsCDATA=true Then
243

set TextSection=XmlDom.createCDATASection(NewElementText)
244

If ElementOBJ.firstchild Is Nothing Then
245

ElementOBJ.appendChild TextSection
246

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

ElementOBJ.replaceChild TextSection,ElementOBJ.firstchild
248

End If
249

Else
250

ElementOBJ.Text=NewElementText
251

End If
252


253

set fNode=ElementOBJ
254

Set UpdateNodeText=ElementOBJ
255

End Function
256


257

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

Function getElementNode(byVal ElementName,byVal testValue)
259

Dim Element,regEx,baseName
260


261

Set getElementNode=nothing
262

If not fopen Then Exit Function
263


264

testValue=Trim(testValue)
265

Set regEx=New RegExp
266

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

regEx.IgnoreCase=true
268

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

Set regEx=nothing
270


271

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


273

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


275

If Element Is Nothing Then
276

'Response.write ElementName&testValue
277

Set getElementNode=nothing
278

Exit Function
279

End If
280


281

Do While LCase(Element.baseName)<>baseName
282

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

If Element Is Nothing Then Exit Do
284

Loop
285


286

If LCase(Element.baseName)<>baseName Then
287

Set getElementNode=nothing
288

Else
289

Set getElementNode=Element
290

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

Set fNode=Element
292

Else
293

Set fANode=Element
294

End If
295

End If
296

End Function
297


298

'删除一个子节点
299

Function removeChild(byVal ElementOBJ)
300

removeChild=false
301

If not fopen Then Exit Function
302


303

Set ElementOBJ=ChildNode(null,ElementOBJ,false)
304

If ElementOBJ Is Nothing Then Exit Function
305


306

'response.write ElementOBJ.baseName
307


308

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

If ElementOBJ Is fNode Then set fNode=Nothing
310

If ElementOBJ.parentNode Is Nothing Then
311

XmlDom.removeChild(ElementOBJ)
312

Else
313

ElementOBJ.parentNode.removeChild(ElementOBJ)
314

End If
315

removeChild=True
316

End If
317

End Function
318


319

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

Function ClearNode(byVal ElementOBJ)
321

set ClearNode=Nothing
322

If not fopen Then Exit Function
323


324

Set ElementOBJ=ChildNode(null,ElementOBJ,false)
325

If ElementOBJ Is Nothing Then Exit Function
326


327

ElementOBJ.text=""
328

ElementOBJ.removeChild(ElementOBJ.firstchild)
329


330

Set ClearNode=ElementOBJ
331

Set fNode=ElementOBJ
332

End Function
333


334

'删除子节点的一个属性
335

Function removeAttributeNode(byVal ElementOBJ,byVal AttributeOBJ)
336

removeAttributeNode=false
337

If not fopen Then Exit Function
338


339

Set ElementOBJ=ChildNode(XmlDom,ElementOBJ,false)
340

If ElementOBJ Is Nothing Then Exit Function
341


342

Set AttributeOBJ=ChildNode(ElementOBJ,AttributeOBJ,true)
343

If not AttributeOBJ Is nothing Then
344

View Code

c#读写xml文件

c#读写xml文件
已知有一个XML文件（bookstore.xml）如下：
"1.0" encoding="gb2312"?>

  "fantasy" ISBN="2-3631-4">
    
    Corets, Eva
    5.95
  

 
1、往节点中插入一个节点：
   XmlDocument xmlDoc=new XmlDocument();
   xmlDoc.Load("bookstore.xml");
   XmlNode root=xmlDoc.SelectSingleNode("bookstore");//查找
   XmlElement xe1=xmlDoc.CreateElement("book");//创建一个节点
   xe1.SetAttribute("genre","李赞红");//设置该节点genre属性
   xe1.SetAttribute("ISBN","2-3631-4");//设置该节点ISBN属性
 
   XmlElement xesub1=xmlDoc.CreateElement("title");
   xesub1.InnerText="CS从入门到精通";//设置文本节点
   xe1.AppendChild(xesub1);//添加到节点中
   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);//添加到节点中
   xmlDoc.Save("bookstore.xml");
//===============================================
结果为：
"1.0" encoding="gb2312"?>

  "fantasy" ISBN="2-3631-4">
    
    Corets, Eva
    5.95
  
  "李赞红" ISBN="2-3631-4">
    
    候捷
    58.3
  

 
2、修改节点：将genre属性值为“李赞红“的节点的genre值改为“update李赞红”，将该节点的子节点的文本修改为“亚胜”。
    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");//保存。
//==================================================
最后结果为：
"1.0" encoding="gb2312"?>

  "fantasy" ISBN="2-3631-4">
    
    Corets, Eva
    5.95
  
  "update李赞红" ISBN="2-3631-4">
    
    亚胜
    58.3
  

 
3、删除 "fantasy" ISBN="2-3631-4">节点的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");
//===========================================
最后结果为：
"1.0" encoding="gb2312"?>

  "2-3631-4">
    
    Corets, Eva
    5.95
  
  
  

 
4、显示所有数据。
   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);//显示子节点点文本
    }
   }

View Code

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
{
    /// 

    /// XmlHelper 的摘要说明
    /// 
    public class XmlHelper
    {
        public XmlHelper()
        {
        }
        /// 

        /// 读取数据
        /// 
        /// 路径
        /// 节点
        /// 属性名，非空时返回该属性值，否则返回串联值
        /// string
        /**************************************************
         * 使用示列:
         * 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;
        }
        /// 

        /// 插入数据
        /// 
        /// 路径
        /// 节点
        /// 元素名，非空时插入新元素，否则在该元素中插入属性
        /// 属性名，非空时插入该元素属性值，否则插入元素值
        /// 值
        /// 
        /**************************************************
         * 使用示列:
         * 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 { }
        }
        /// 

        /// 修改数据
        /// 
        /// 路径
        /// 节点
        /// 属性名，非空时修改该节点属性值，否则修改节点值
        /// 值
        /// 
        /**************************************************
         * 使用示列:
         * 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 { }
        }
        /// 

        /// 删除数据
        /// 
        /// 路径
        /// 节点
        /// 属性名，非空时删除该节点属性值，否则删除节点值
        /// 值
        /// 
        /**************************************************
         * 使用示列:
         * 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：
"1.0" encoding="utf-8"?>

==================================================
使用方法：
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("
" + XmlHelper.Read(xml, "/Root/Studio/Site/Master", "") + "
");
//读取属性值
//Response.Write("
" + XmlHelper.Read(xml, "/Root/Studio/Site", "Url") + "
");
//读取特定属性值
//Response.Write("
" + XmlHelper.Read(xml, "/Root/Studio/Site[@Name='丁香鱼工作室']", "Url") + "
");
//删除属性
//XmlHelper.Delete(xml, "/Root/Studio/Site[@Name='小路工作室']", "Url");
//删除元素
//XmlHelper.Delete(xml, "/Root/Studio", "");
 

View Code

 

转载于:https://www.cnblogs.com/blogpro/p/11457027.html