zoukankan      html  css  js  c++  java
  • 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 > 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文件
            }
        }
        /**//// <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;
                }
            }
        }
    }
      
    View Code

    C#解析XML基础

    (转) C#解析XML基础
      
    
    用的是一种很笨的方法,但可以帮助初学者了解访问XML节点的过程。 
    已知有一个XML文件(bookstore.xml)如下:
    
    1 <?xml version="1.0" encoding="gb2312"?> 
    2  <bookstore> 
    3   <book genre="fantasy" ISBN="2-3631-4"> 
    4     <title>Oberon's Legacy</title> 
    5     <author>Corets, Eva</author> 
    6     <price>5.95</price> 
    7   </book> 
    8  </bookstore>
    
     
     1、往<bookstore>节点中插入一个<book>节点:
    
     1  XmlDocument xmlDoc=new XmlDocument();
     2    xmlDoc.Load("bookstore.xml");
     3    XmlNode root=xmlDoc.SelectSingleNode("bookstore");//查找<bookstore>
     4     XmlElement xe1=xmlDoc.CreateElement("book");//创建一个<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);//添加到<book>节点中
    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);//添加到<bookstore>节点中
    17     xmlDoc.Save("bookstore.xml");
    
     //================ 
     
    结果为:
    
     1 <?xml version="1.0" encoding="gb2312"?> 
     2  <bookstore> 
     3   <book genre="fantasy" ISBN="2-3631-4"> 
     4     <title>Oberon's Legacy</title> 
     5     <author>Corets, Eva</author> 
     6     <price>5.95</price> 
     7   </book> 
     8   <book genre="李赞红" ISBN="2-3631-4"> 
     9     <title>CS从入门到精通</title> 
    10     <author>候捷</author> 
    11     <price>58.3</price> 
    12   </book> 
    13  </bookstore>
    
     
    2、修改节点:将genre属性值为“李赞红“的节点的genre值改为“update李赞红”,将该节点的子节点<author>的文本修改为“亚胜”。
    
     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 <?xml version="1.0" encoding="gb2312"?> 
     2  <bookstore> 
     3   <book genre="fantasy" ISBN="2-3631-4"> 
     4     <title>Oberon's Legacy</title> 
     5     <author>Corets, Eva</author> 
     6     <price>5.95</price> 
     7   </book> 
     8   <book genre="update李赞红" ISBN="2-3631-4"> 
     9     <title>CS从入门到精通</title> 
    10     <author>亚胜</author> 
    11     <price>58.3</price> 
    12   </book> 
    13  </bookstore>
    
     
      3、删除 <book genre="fantasy" ISBN="2-3631-4">节点的genre属性,删除 <book 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 <?xml version="1.0" encoding="gb2312"?> 
     2  <bookstore> 
     3   <book ISBN="2-3631-4"> 
     4     <title>Oberon's Legacy</title> 
     5     <author>Corets, Eva</author> 
     6     <price>5.95</price> 
     7   </book> 
     8   <book> 
     9   </book> 
    10  </bookstore>
    
     
      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         /// <summary>  
    13         /// 创建一个带有根节点的Xml文件  
    14         /// </summary>  
    15         /// <param name="FileName">Xml文件名称</param>  
    16         /// <param name="rootName">根节点名称</param>  
    17         /// <param name="Encode">编码方式:gb2312,UTF-8等常见的</param>  
    18         /// <param name="DirPath">保存的目录路径</param>  
    19         /// <returns></returns>  
    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         /// <summary>  
    44         /// 插入一个节点和它的若干子节点  
    45         /// </summary>  
    46         /// <param name="XmlFile">Xml文件路径</param>  
    47         /// <param name="NewNodeName">插入的节点名称</param>  
    48         /// <param name="HasAttributes">此节点是否具有属性,True为有,False为无</param>  
    49         /// <param name="fatherNode">此插入节点的父节点</param>  
    50         /// <param name="htAtt">此节点的属性,Key为属性名,Value为属性值</param>  
    51         /// <param name="htSubNode">子节点的属性,Key为Name,Value为InnerText</param>  
    52         /// <returns>返回真为更新成功,否则失败</returns>  
    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         /// <summary>  
    87         /// 更新节点  
    88         /// </summary>  
    89         /// <param name="XmlFile">Xml文件路径</param>  
    90         /// <param name="fatherNode">需要更新节点的上级节点</param>  
    91         /// <param name="htAtt">需要更新的属性表,Key代表需要更新的属性,Value代表更新后的值</param>  
    92         /// <param name="htSubNode">需要更新的子节点的属性表,Key代表需要更新的子节点名字Name,Value代表更新后的值InnerText</param>  
    93         /// <returns>返回真为更新成功,否则失败</returns>  
    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         /// <summary>  
    112         /// 删除指定节点下的子节点  
    113         /// </summary>  
    114         /// <param name="XmlFile">Xml文件路径</param>  
    115         /// <param name="fatherNode">制定节点</param>  
    116         /// <returns>返回真为更新成功,否则失败</returns>  
    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         /// <summary>  
    137         /// 设置节点属性  
    138         /// </summary>  
    139         /// <param name="xe">节点所处的Element</param>  
    140         /// <param name="htAttribute">节点属性,Key代表属性名称,Value代表属性值</param>  
    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         /// <summary>  
    149         /// 增加子节点到根节点下  
    150         /// </summary>  
    151         /// <param name="rootNode">上级节点名称</param>  
    152         /// <param name="XmlDoc">Xml文档</param>  
    153         /// <param name="rootXe">父根节点所属的Element</param>  
    154         /// <param name="SubNodes">子节点属性,Key为Name值,Value为InnerText值</param>  
    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         /// <summary>  
    166         /// 更新节点属性和子节点InnerText值  
    167         /// </summary>  
    168         /// <param name="root">根节点名字</param>  
    169         /// <param name="htAtt">需要更改的属性名称和值</param>  
    170         /// <param name="htSubNode">需要更改InnerText的子节点名字和值</param>  
    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对应了节点的属性名称,如<Fan Nickname="Jacky">这里的Nickname就是哈希表中的Key值,而Jacky就对应哈希表中的Value值,这样,你可以在插入节点前,把该节点的属性(多个)名称和对应的值先存入哈希表中,然后再传给函数即可增加多个属性。
    b.htSubNode:存储了子节点的数据,子节点包括他的名字和InnerText值,如<Age>23</Age>这里的Age就是子节点名字,23就是节点的InnerText值。
    2、修改节点函数中的哈希表说明:
    a.htAtt:存储了待更新的属性值,传入函数后,函数将逐一对比,查看节点中是否含有htAtt的Key值,如果含有,则表明节点的该属性的值(Value)将被htAtt中相应的Value替换。
    b.htSubNode:存储了子节点的修改信息,传入函数后,函数将逐一对比,查看子节点的节点名字是否含有htSubNode的Key值,如果含有,则表明此子节点需要被更新,则此节点的InnerText将被修改为相应的htSubNode的Value值。
    好了,下面我们来看看类库运行起来的效果吧:
    一、先创建Xml文件,如下:
     
    我们来这个路径下,打开刚才创建的xml文档,内容如下:
    Xml代码  
    
    210 <a href="http://www.xueit.com/cshare/show-4275-2.aspx"><?xml version="1.0" encoding="utf-8"?>  
    211 <AppSettings/></a>  
     
     
    二、执行插入节点操作,如下图:(插入的节点数据在程序中,请稍候在本文尾部下载)
    我们再打开这个文件,看看插入效果和程序中的一样么:
    Xml代码  
    
    212 <?xml version="1.0" encoding="utf-8"?>  
    213 <AppSettings>  
    214   <Fan Nickname="Jacky">  
    215     <Age>23</Age>  
    216   </Fan>  
    217 </AppSettings>  
     
    三、我们修改一下节点内容:
    
     
    修改效果如下:
    Xml代码  
    
    218 <?xml version="1.0" encoding="utf-8"?>  
    219 <AppSettings>  
    220   <Fan Nickname="Doggy">  
    221     <Age>3</Age>  
    222   </Fan>  
    223 </AppSettings>  
     
    四、好了,删除刚才的那些节点吧:
    
    
    又变回原样了:
     
    Xml代码  
    
    224 <?xml version="1.0" encoding="utf-8"?>  
    225 <AppSettings/>  
     
    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);
    输出为:
    <Address Type="Billing">
      <Name>Tai YeeName>
      <Street>8 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="123" Data2="456">
      <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", 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);
     
    输出结果:
     
    <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", 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);
     
    输出结果:
     
    <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", 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);
     
    输出结果为:
     
    <Root Att1="1" Att2="2" Att3="3" />
    <Root Att1="1" Att2="22" Att3="3" />
    <Root Att1="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);
     
    输出结果:
     
    <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>
     
    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)如下:
    <?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>
     
    1、往<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>
     
    2、修改节点:将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>
     
    3、删除 <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>
     
    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
    {
        /// <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", "");
     
    View Code
  • 相关阅读:
    Git log、diff、config 进阶
    Firefox 修改User Agent
    改Chrome的User Agent,移动版网络
    ThinkPHP 更新数据 save方法
    ThinkPHP:create()方法有什么用呢?
    js控制select选中显示不同表单内容
    GPS通讯协议协议(NMEA0183)
    Linux pkg-config命令
    OpenCV编程
    GTK编程
  • 原文地址:https://www.cnblogs.com/blogpro/p/11457027.html
Copyright © 2011-2022 走看看