精华内容
下载资源
问答
  • C# winfrom操作xml_读写修改xml及写入数据库,这是共用了60积分下载的,这里分享给大家一起研究研究,里面有四个操作xml文件数据库的DEMO方法。各位有好的方法欢迎一起沟通学习。
  • 使用qt5操作xml文件,删除xml文件中的节点和修改xml文件中节点的数据值。 那位大神知道,如果有代码就更好了。 谢谢
  • xml操作xml操作xml操作xml操作xml操作xml操作xml操作xml操作xml操作xml操作xml操作xml操作xml操作xml操作xml操作xml操作xml操作xml操作xml操作xml操作xml操作xml操作xml操作xml操作xml操作
  • 操作XML

    千次阅读 2016-04-23 21:23:18
    操作XML   千呼万唤始出来,BB了这么多东西,咱们终于可以写点东西了,前方内容很多,楼主正在考虑是否可以分开写.   因为啥东西多呢?前面说了那么多关于XML的东西,什么转换啊,DTD啊,手都说了,我...

    操作XML

     

    千呼万唤始出来,BB了这么多东西,咱们终于可以写点东西了,前方内容很多,楼主正在考虑是否可以分开写.

     

    因为啥东西多呢?前面说了那么多关于XML的东西,什么转换啊,DTD,手都说了,我要是不给你演示一遍你说我骗你咋办?

     

    首先记住一点:操作XML文档时,操作的单元是节点,首先要知道XML文档有哪些节点类型..NET,有关XML的类型位于System.Xml.*命名空间下,System.Xml.XmlNodeType枚举列出了XML的节点类型.

     

    namespace System.Xml
    {
        //
        // 摘要:
        //     指定节点的类型。
        public enum XmlNodeType
        {
            //
            // 摘要:
            //     如果未调用 Read 方法,则由 System.Xml.XmlReader 返回。
            None = 0,
            //
            // 摘要:
            //     元素(例如,<item>)。
            Element = 1,
            //
            // 摘要:
            //     特性(例如,id='123')。
            Attribute = 2,
            //
            // 摘要:
            //     节点的文本内容。
            Text = 3,
            //
            // 摘要:
            //     CDATA 节(例如,<![CDATA[my escaped text]]>)。
            CDATA = 4,
            //
            // 摘要:
            //     实体引用(例如,#)。
            EntityReference = 5,
            //
            // 摘要:
            //     实体声明(例如,<!ENTITY...>)。
            Entity = 6,
            //
            // 摘要:
            //     处理指令(例如,<?pi test?>)。
            ProcessingInstruction = 7,
            //
            // 摘要:
            //     注释(例如,<!-- my comment -->)。
            Comment = 8,
            //
            // 摘要:
            //     作为文档树的根的文档对象提供对整个 XML 文档的访问。
            Document = 9,
            //
            // 摘要:
            //     由以下标记指示的文档类型声明(例如,<!DOCTYPE...>)。
            DocumentType = 10,
            //
            // 摘要:
            //     文档片段。
            DocumentFragment = 11,
            //
            // 摘要:
            //     文档类型声明中的表示法(例如,<!NOTATION...>)。
            Notation = 12,
            //
            // 摘要:
            //     标记间的空白。
            Whitespace = 13,
            //
            // 摘要:
            //     混合内容模型中标记间的空白或 xml:space="preserve" 范围内的空白。
            SignificantWhitespace = 14,
            //
            // 摘要:
            //     末尾元素标记(例如,</item>)。
            EndElement = 15,
            //
            // 摘要:
            //     由于调用 System.Xml.XmlReader.ResolveEntity 而使 XmlReader 到达实体替换的末尾时返回。
            EndEntity = 16,
            //
            // 摘要:
            //     XML 声明(例如,<?xml version='1.0'?>)。
            XmlDeclaration = 17
        }
    }

    上面代码不是我写的,是微软写的XML的节点类型.

     

    对于节点类型,有与之相应的.NET类型.比如,对于注释节点,XmlComment类型;对于空格节点,XmlWhitespace类型;对于元素节点,XmlElement类型.这些类型均直接或间接继承共同的基类XmlNode.就像所有的类都是继承自object一样.

     

     

    使用XmlReaderXmlWriter

     

    1.使用XmlReader读取XML文档

     

    先创建一个完整的XML文件movieList.xml

    <?xml version="1.0" encoding="utf-8" ?>
    <!DOCTYPE movieList [<!ENTITY Bruce "布鲁斯.威利斯"><!ENTITY Jai "杰.卡特尼">]>
    <movieList>
      <!--新近上映的电影-->
      <movie id="1" title="魔境仙踪" director="山姆.雷米" release="2012-3-6">
        <starring>詹姆斯.弗兰克/米拉.克丽丝</starring>
        <genreList>
          <genre>冒险</genre>
          <genre>科幻</genre>
          <genre>爱情</genre>
        </genreList>
      </movie>
      <movie id="2" title="龙胆虎威" director="约翰.摩尔" release="2016-9-6">
        <starring>&Bruce;/&Jai;</starring>
        <genreList>
          <genre>搞笑</genre>
          <genre>恐怖</genre>
          <genre>惊悚</genre>
        </genreList>
      </movie>
    </movieList>


     

    接下来使用XmlReader类型对它进行读取,XmlReader的使用和StreamReader类似,只不过StreamReader是以”行”为单位进行读取,XmlReader是以”节点”为单位进行读取.节点在.NET中由System.Xml.XmlNode类型表示,对于节点来说,最重要的属性是名称和值,分别对应XmlNode类型的NameValue属性.

     

    XmlReader是一个抽象类,可以通过调用它的静态方法Create()来创建对象.


    建一个控制台项目.下面的代码展示了读取所有的节点,并输出了节点的类型,名称和值.对于元素节点,如果存在属性,还输出了属性的名称和值.

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using System.Xml;
     
    namespace 操作XML
    {
        class Program
        {
            static void Main(string[] args)
            {
                XmlReaderSettings settings = new XmlReaderSettings();
                settings.DtdProcessing = DtdProcessing.Parse;//默认为Prohibit
                settings.IgnoreWhitespace = true;
     
                XmlReader reader = XmlReader.Create("movieList.xml", settings);
     
                while (reader.Read())
                {
                    string indent = new string(' ',reader.Depth*3);
                    string line = string.Format("{0}{1} | {2} - {3}",indent,reader.NodeType,reader.Name,reader.Value);
                    Console.WriteLine(line);
     
                    line = "";
                    if (reader.NodeType==XmlNodeType.Element&&reader.HasAttributes)
                    {
                        for (int i = 0; i <reader.AttributeCount; i++)
                        {
                            reader.MoveToAttribute(i);
                            line += string.Format("{0}[{1}, {2}]\r\n",indent,reader.Name,reader.Value);
                        }
                        Console.WriteLine(line);
                    }
                }
                reader.Close();
            }
        }
    }


    注意一点,movieList.xml文件需要放在debug目录下.

     

    while(reader.Read())循环中的代码部分相对简单,有下面几点需要注意:

    (1).不是所有的节点都有名称或者值,对于Comment节点来说,只有值没有名称.对于Element接地拿来说,只有名称没有值.

    (2)尽管XmlReader是以只读的,前进的方式进行读取,但是对于元素的属性,可以根据所以访问任意属性.

    (3)XmlReader具有一个属性ValueType.

     

    XmlReader还有两组强类型方法(注意这里说的是组,说明还有asInt,asFloat,asLong,asObject.),例如:

    ReadContentAsBoolean();
     
    ReadElementContentAsBoolean();


     

    它们用于简化操作,省却一些枯燥的类型转换的代码.这两组方法最主要的区别是:ReadContentAsXXX()方法应在Text节点上调用,ReadElementContentAsXXX()方法应在Element节点上调用.这两组方法都会使XmlReader的指针前进到下一节点,效果上相当于调用了Read()方法.

     

     

    2.使用XmlWriter生成XML文档.

     

    使用XmlWriter生成XML文档也是比较容易的.注意到它具有只写,单向前进的特点,因此使用XmlWriter不能直接修改现有的XML文档,只能用于创建全新的XML文档.如果要使用XmlWriter修改XML,比如修改某个元素的属性值,那么可以配合XmlReader来间接完成.

     

     

    下面的代码使用XmlWriter生成了和之前创建的movieList.xml完全一样的XML文档.

                #region XmlWriter
                string filePath = "movieList2.xml";
                XmlWriterSettings settings = new XmlWriterSettings();
                settings.Encoding = System.Text.Encoding.UTF8;
                settings.Indent = true;
                settings.IndentChars = "\t";
                settings.OmitXmlDeclaration = false;
     
                XmlWriter writer = XmlWriter.Create(filePath, settings);
                writer.WriteStartDocument();//xml声明
                writer.WriteDocType("movieList", null, null, "<!ENTITY Brace \"布鲁斯.威利斯\"><!ENTITY Jai \"杰.科特尼\">");
                writer.WriteStartElement("movieList");
                writer.WriteComment("新近上映电影信息");
                writer.WriteStartElement("movie");
                writer.WriteAttributeString("id", "1");
                writer.WriteAttributeString("title", "魔境仙踪");
                writer.WriteAttributeString("director", "山姆.雷米");
                writer.WriteAttributeString("release", "2012-9-6");
                writer.WriteElementString("starring", "詹姆斯.弗兰克/米拉.克丽丝");
                writer.WriteStartElement("genreList");
                writer.WriteElementString("genre", "科幻");
                writer.WriteElementString("genre", "冒险");
                writer.WriteElementString("genre", "动作");
                writer.WriteEndElement();//genreList
                writer.WriteEndElement();//movie
     
                //writer.WriteStartElement("syx","movie","");
                writer.WriteStartElement("movie");
                writer.WriteAttributeString("id", "2");
                writer.WriteAttributeString("title", "龙胆虎威");
                writer.WriteAttributeString("director", "约翰.摩尔");
                writer.WriteAttributeString("release", "2013-6-9");
                //writer.WriteStartElement("syx","starring",null);
                writer.WriteStartElement("starring");
                writer.WriteEntityRef("Brace");
                writer.WriteString("/");
                writer.WriteEntityRef("Jai");
                writer.WriteEndElement();//starring
                writer.WriteStartElement("genreList");
                writer.WriteElementString("genre", "喜剧");
                writer.WriteElementString("genre", "恐怖");
                writer.WriteElementString("genre", "搞笑");
                writer.WriteEndElement();//genreList
                writer.WriteEndElement();//movie
     
                writer.WriteEndElement();//movieList
                writer.WriteEndDocument();
                writer.Flush();
                writer.Close();
     
                #endregion


    这段无脑代码楼主写了接近一个小时,真是醉了!!!

     

    XmlReader类似,在创建XmlWriter时也可以传入一个XmlWriterSettings类型的对象,在本例中,设置了缩进的格式,生成文档的字符编码信息.XmlWriter类型提供的方法相对简单,通过方法名称和注释就可以了解很多了.

     

    注释掉的两行内容演示了如何为元素添加命名空间和命名空间的前缀:

    //添加movie元素,添加命名空间和命名空间前缀
                //writer.WriteStartElement("syx","movie","");
    //添加命名空间前缀
                //writer.WriteStartElement("syx","starring",null);


     

    使用XmlWriter生成XML文档很繁琐,由于XML不过是纯文本文件,元素名称和文档结构通常是固定的,只是元素标记的文本值和属性值不同,因此可以直接写入原始文本,比如这样:

                string element =
                    @"  <movie> id=""{0}"" title=""{1}"" director=""{2}"" release=""{3}"">
                                    <starring>{4}/{5}</starring>                    
                                    <genreList>
                                            <genre>{6}</genre>
                                            <genre>{7}</genre>
                                            <genre>{8}</genre>
                                    </genreList>
                        </movie>";
                element = string.Format(element, "2", "龙胆虎威", "约翰.摩尔", "2012-9-9", "&Bruce;", "/&Jai;", "动作", "爱情", "喜剧");
                writer.WriteString("\r\n");
                writer.WriteRaw(element);
                writer.WriteString("\r\n");
     


    WriteRaw()方法和WriteString()方法的区别是:WtiteString()方法会对字符串进行转义,例如将”\r\n”变为换行,”<”变为”<”;WriteRaw则会将”\r\n”以文本的形式写入到XML文档中.



    使用XmlDocumentXPath

     

    使用XmlReader遍历文档是很方便的,使用XmlWriter生成一个新的XML文档也很容易.但是对现有的XML进行修改,例如添加一个元素或修改一个属性值,就比较麻烦了.此时,可以使用XmlDocument对象,通过调用DOM方法对文档进行修改,然后再保存.由于DOM已经进行了标准化,很多语言都对他进行了支持,比如JS,因此这里的很多方法与JS中都是一致的,比如GetElementByID(),GetElementByTagName(),AppendChild(),InsertAfter().

     

    下面的代码演示了在movieList.xml文档中添加一组新的元素:

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using System.Xml;
     
    namespace 使用XmlDocument和XPath
    {
        class Program
        {
            static void Main(string[] args)
            {
                string filePath = "movieList.xml";
                XmlDocument doc = new XmlDocument();
                doc.Load(filePath);
     
                XmlElement movie = doc.CreateElement("movie");
                XmlAttribute attr = doc.CreateAttribute("id");
                attr.Value = "3";
                movie.Attributes.Append(attr);
     
                attr = doc.CreateAttribute("title");
                attr.Value="速度与激情";
                movie.Attributes.Append(attr);
     
                attr = doc.CreateAttribute("direactor");
                attr.Value = "范.迪塞尔";
                movie.Attributes.Append(attr);
     
                attr = doc.CreateAttribute("release");
                attr.Value = "2016-9-9";
                movie.Attributes.Append(attr);
     
                XmlElement starring = doc.CreateElement("starring");
                starring.InnerText = "奥巴马";
                movie.AppendChild(starring);
     
                XmlElement genreList = doc.CreateElement("genreList");
                XmlElement genre = doc.CreateElement("genre");
                genre.InnerText = "刺激";
                genreList.AppendChild(genre);
     
                genre = doc.CreateElement("genre");
                genre.InnerText = "冒险";
                genreList.AppendChild(genre);
     
                movie.AppendChild(genreList);
     
                XmlElement root = doc.DocumentElement;
                root.AppendChild(movie);
     
                doc.Save("movieList3.xml");
            }
        }
    }


     

    上面的代码可以说是平铺样式的,看方法的名称就知道啥意思.需要留意的有几点:

    (1).Element类型节点的Value属性是没有值的.因此如果要设置元素的两个标记中间的文本(<tag>文本</tag>),使用InnerTextInnerXml属性.

    (2).注意区别上面的XmlDocument类型的docXmlElement类型root.doc表示的是整个XML文档,包含了XML声明,文档类型声明,注释等所有内容;root则代表文档的根节点,movieList元素.

     

     

    接下来看一个例子,id属性为2movie元素做如下修改

    (1).修改title属性

    (2).修改starring元素,添加一个主演

    (3).修改genreList元素的子元素,删除一个子元素

     

    要想修改某一元素或者属性,首先需要选择元素.选择元素的方法很多,比方说简单易用的GetElementById(),这里为大家演示如何使用XPATH来获取元素.下面是代码:

     

                string filePath = "movieList3.xml";
                XmlDocument doc = new XmlDocument();
                doc.Load(filePath);
     
                XmlElement root = doc.DocumentElement;
                XmlNode movie = root.SelectSingleNode("movie[@id=2]");
                XmlNode titleAttr = movie.SelectSingleNode("@title");
                titleAttr.Value = "A Good Day to Die Hard";
     
                XmlNode starring = movie.SelectSingleNode("starring");
                starring.InnerText = starring.InnerText + " / 梅西";
     
                XmlNode genre = movie.SelectSingleNode("genreList/genre[3]");
                XmlNode genreList = movie.SelectSingleNode("genreList");
                genreList.RemoveChild(genre);
     
                doc.Save("movieList4.xml");

     

    这段代码主要调用的方法是SelectSingleNode(),它用于接受一个XPATH字符串,然后选中符合条件的第一个节点.如果想获得XPATH的全部节点,可以使用SelectNodes()方法.

     

    接下来的一个实例是如何对XmlDocument进行遍历,便利的方式和数据结构中”树的遍历”是一样的,因为XmlDocument本身就是一个树形结构.

     

     

    当然,如果要遍历XML文档,那么应该优先考虑xmlReader而不是XmlDocument.

    测试代码:

                string filePath = "movieList4.xml";
                XmlDocument doc = new XmlDocument();
                doc.Load(filePath);
     
                XmlNode root = doc.DocumentElement;
     
                showNode(root);
     
            private static void showNode(XmlNode root)
            {
                if (root.NodeType==XmlNodeType.Text)
                {
                    Console.WriteLine(root.Value);
                }
                if (root.NodeType==XmlNodeType.Element)
                {
                    Console.WriteLine(root.Name);
                }
                if (root.Attributes!=null&&root.Attributes.Count>0)
                {
                    foreach (XmlAttribute attr  in root.Attributes)
                    {
                        Console.Write("{0}={1} ",attr.Name,attr.Value);
                    }
                    Console.WriteLine();
                }
                XmlNodeList chiledList = root.ChildNodes;
                foreach (XmlNode child in chiledList)
                {
                    showNode(child);
                }
            }
     


     

     

    使用XSD验证XML

     

    如果要验证movieList.xml的有效性,那么首先需要一个XSD模式定义文件.XSDXML一样是纯文本文件,其本身也是一个XML文件,使用文本编辑器就可以创建.VS中也提供了创建XSD文件的模板,在项目中选择”添加”和”新建项”,然后选择”XML架构”,单机添加,就在项目下新建了一个空的XSD文件.如果想从现用的XML文档生成模式,可以打开”VS命令提示”,然后使用xsd.exe实用工具来创建,可以用下面的语句生成movieList.xml.

    >xsd movieList.xml   //楼主亲测不行!!!

    为啥呢?
    因为你需要赞数取消掉实体引用的部分,&Bruce;&Jai;!!!

     

    对于movieList.xml生成的XSD文件如下:

    <?xml version="1.0" encoding="utf-8"?>
    <xs:schema id="movieList" xmlns="" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
      <xs:element name="movieList" msdata:IsDataSet="true" msdata:Locale="en-US">
        <xs:complexType>
          <xs:choice minOccurs="0" maxOccurs="unbounded">
            <xs:element name="movie">
              <xs:complexType>
                <xs:sequence>
                  <xs:element name="starring" type="xs:string" minOccurs="0" msdata:Ordinal="0" />
                  <xs:element name="genreList" minOccurs="0" maxOccurs="unbounded">
                    <xs:complexType>
                      <xs:sequence>
                        <xs:element name="genre" nillable="true" minOccurs="0" maxOccurs="unbounded">
                          <xs:complexType>
                            <xs:simpleContent msdata:ColumnName="genre_Text" msdata:Ordinal="0">
                              <xs:extension base="xs:string">
                              </xs:extension>
                            </xs:simpleContent>
                          </xs:complexType>
                        </xs:element>
                      </xs:sequence>
                    </xs:complexType>
                  </xs:element>
                </xs:sequence>
                <xs:attribute name="id" type="xs:string" />
                <xs:attribute name="title" type="xs:string" />
                <xs:attribute name="director" type="xs:string" />
                <xs:attribute name="release" type="xs:string" />
              </xs:complexType>
            </xs:element>
          </xs:choice>
        </xs:complexType>
      </xs:element>
    </xs:schema>


     

    使用XSD.exe实用工具生成的XSD文件,其中的元素文本,属性值的类型军默认是字符串,这一点可以从type=”xs:string”语句可以看出.除了字符串以外,XML模式还定义了其他的类型,比如unsignedInt,boolean.

     

    创建好XSD文件以后,就可以对XML文档的有效性进行验证,代码如下:

    测试代码:

                string filePath = "movieList.xml";
                string xsdPath = "movieList.xsd";
     
                XmlReaderSettings settings = new XmlReaderSettings();
                settings.DtdProcessing = DtdProcessing.Parse;
                settings.ValidationType = ValidationType.Schema;
                settings.Schemas.Add(null,"movieList.xsd");
                settings.ValidationEventHandler += new ValidationEventHandler(settings_ValidationEventHandler); ;
     
                XmlReader reader = XmlReader.Create(filePath,settings);
                while (reader.Read())
                {
                    
                }
                Console.WriteLine("Complete!");


    函数代码:

            private static void settings_ValidationEventHandler(object sender, ValidationEventArgs e)
            {
                Console.WriteLine("line: {0},column: {1},Error: {2}",e.Exception.LineNumber,e.Exception.LinePosition,e.Message);
            }


     

    上面的代码与前面使用XmlReader读取XML文档时类似的,区别是在XmlReaderSettings对象上设置了Schemas属性,ValidationType属性和ValidationEventHandler事件.ValidationEventHandler在验证文档出错时进行了方法回调,XmlReader在出错后会继续验证下一节点.settings_ValidationEventHandler()回调方法中,打印了出错的信息.由于这个movieList.xsd模式文件本身就是从movieList.xml直接生成的,因此不会出错,只会在控制台出现”Complete”.作为测试,我们可以修改一下movieList.xsd,title的类型修改为unsignedInt,让它接受无符号类型:

                <xs:attribute name="title" type="xs:unsignedInt" />


     

    此时就会这样:

    line: 5,column: 17,Error: “title”特性无效 - 根据数据类型“http://www.w3.org/2001/XMLSchema:unsignedInt”,值“魔境仙踪”无效 -  字符串“魔境仙踪”不是有效的 UInt32 值。
    line: 13,column: 17,Error: “title”特性无效 - 根据数据类型“http://www.w3.org/2001/XMLSchema:unsignedInt”,值“龙胆虎威”无效 - 字符串“龙胆虎威”不是有效的 UInt32 值。
    Complete!


     

     

     

    使用XSLTXML进行转换

     

    使用XSLT最常见的一个场景就是将XML转换为XHTML,以便在浏览器中对XML进行显示.要进行XML格式转换,首先需要创建一个XSLT文件,这也是一个XML文件.下面的movieList.xslt文件将movieList.xml转换为了一个HTML表格:

    <?xml version="1.0" encoding="utf-8"?>
    <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
        xmlns:msxsl="urn:schemas-microsoft-com:xslt" exclude-result-prefixes="msxsl"
    >
        <xsl:output method="html" indent="yes"/>
     
        <xsl:template match="/">
          <table border="1">
            <tr>
              <th>标题</th>
              <th>导演</th>
              <th>上映日期</th>
              <th>主演</th>
              <th>类型</th>
            </tr>
            <xsl:for-each select="movieList/movie">
              <tr>
                <td>
                  <xsl:value-of select="@director"/>
                </td>
                <td>
                  <xsl:value-of select="@release"/>
                </td>
                <td>
                  <xsl:value-of select="@starring"/>
                </td>
                <td>
                  <xsl:for-each select="genreList/genre">
                    <xsl:value-of select="."/>
                  </xsl:for-each>
                </td>
              </tr>
            </xsl:for-each>
          </table>
        </xsl:template>
    </xsl:stylesheet>


    上面代码只应用了XSLT中最少和最基本的内容:

    (1).xsl:for-each,用于循环选出选中的节点

    (2).xsl:value-of,用于输出选中的节点的值

     

    这两个元素都有一个属性”select”,这个属性接收XPATH字符串,用于选择XML中的节点.修改movieList.xml,使用处理指令movieList.xslt文件引用进来:

    <?xml version="1.0" encoding="utf-8" ?>
    <!--引用xslt-->
    <?xml-stylesheet type="text/xsl" href="movieList.xslt"?>
    <!DOCTYPE movieList [<!ENTITY Bruce "布鲁斯.威利斯"><!ENTITY Jai "杰.卡特尼">]>
    <movieList>
      <!--新近上映的电影-->
      <movie id="1" title="魔境仙踪" director="山姆.雷米" release="2012-3-6">
        <starring>詹姆斯.弗兰克/米拉.克丽丝</starring>
        <genreList>
          <genre>冒险</genre>
          <genre>科幻</genre>
          <genre>爱情</genre>
        </genreList>
      </movie>
      <movie id="2" title="龙胆虎威" director="约翰.摩尔" release="2016-9-6">
        <starring>&Bruce;/&Jai;</starring>
        <genreList>
          <genre>搞笑</genre>
          <genre>恐怖</genre>
          <genre>惊悚</genre>
        </genreList>
      </movie>
    </movieList>


     

    如果使用兼容XSLT的浏览器打开会看到一个表格.

     

    如果浏览器不支持XSLT,就需要XSLT的转换结果----HTML,此时可以使用.NET中的XslCompiledTransform类型来完成:

                XmlReaderSettings settings = new XmlReaderSettings();
     
                settings.DtdProcessing = DtdProcessing.Parse;
                XmlReader reader = XmlReader.Create("movieList.xml",settings);
     
                XmlWriterSettings settings2 = new XmlWriterSettings();
                settings2.OmitXmlDeclaration = true;
                XmlWriter writer = XmlWriter.Create("movieList.html",settings2);
     
                XslCompiledTransform transform = new XslCompiledTransform();
                transform.Load("movieList.xslt");
                transform.Transform(reader,writer);


     

    上面的代码创建乐一个movieList.heml文件,它只包含了一个HTML表格.Transform(0方法接受两个参数,分别为XmlReaderXmlWriter类型.XmlWriterSettings的设置中,OmitXmlDeclaration属性设置为true,标书忽略XML声明,否则在生成的html文件中会出现”<?xml version=”1.0” encoding=”UTF-8”?>”

     

    这样的话,关于XML的东西就算是说完了,不知道你记住了多少东西,前面是对XML以及相关概念进行了描述,后面是对XML操作进行了演示.

    展开全文
  • 操作xml文件(创建、修改、保存等编辑操作)
  • php操作xml

    2020-10-26 19:12:55
    分步学习php操作xml:XML概念、DOMDocument对象、加载xml、读取/遍历节点与属性、修改属性/节点、添加元素/属性、删除属性/节点,学会上面这些就可以顺利操作XML了。
  • 修改xml节点的值修改xml节点的值

    热门讨论 2010-07-22 21:04:10
    修改xml节点的值 很好很经典修改xml节点的值 很好很经典修改xml节点的值 很好很经典修改xml节点的值 很好很经典
  • 动态生成Rss文件 Xml操作 Xml文件的修改动态生成Rss文件 Xml操作 Xml文件的修改动态生成Rss文件 Xml操作 Xml文件的修改动态生成Rss文件 Xml操作 Xml文件的修改动态生成Rss文件 Xml操作 Xml文件的修改动态生成Rss文件...
  • 修改xml属性值

    2018-06-10 14:51:27
    这个是个人修改xml属性值的代码,
  • XmlDocument操作XML

    万次阅读 2019-07-03 16:48:26
    C# XmlDocument操作XML XML:Extensible Markup Language(可扩展标记语言)的缩写,是用来定义其它语言的一种元语言,其前身是SGML(Standard Generalized Markup Language,标准通用标记语言)。它没有标签集(t...

    https://www.cnblogs.com/fengxuehuanlin/p/5631664.html

    C# XmlDocument操作XML

    XML:Extensible Markup Language(可扩展标记语言)的缩写,是用来定义其它语言的一种元语言,其前身是SGML(Standard Generalized 
    Markup Language,标准通用标记语言)。它没有标签集(tag set),也没有语法规则(grammatical rule),但是它有句法规则(syntax rule)。
    任何XML文档对任何类型的应用以及正确的解析都必须是良构的(well-formed),即每一个打开的标签都必须有匹配的结束标签,不得
    含有次序颠倒的标签,并且在语句构成上应符合技术规范的要求。XML文档可以是有效的(valid),但并非一定要求有效。所谓有效文档是指其符合其文档
    类型定义(DTD)的文档。如果一个文档符合一个模式(schema)的规定,那么这个文档是"模式有效的(schema valid)"。
      XML文件在存储、交换和传输数据信息上有着很方便处理,那么今天这篇文章主要讲一下用C#如何实现对XML文件的基本操作,
    如:创建xml文件,增、删、改、查xml的节点信息。所使用的方法很基础,方便易懂(用于自己的学习和记忆只需,同时也希望能够给你带来一些帮助,
    如有不合适的地方欢迎大家批评指正)。
      本文的主要模块为:
        ① :生成xml文件
        ② :遍历xml文件的节点信息
        ③ :修改xml文件的节点信息
        ④ :向xml文件添加节点信息
        ⑤ :删除指定xml文件的节点信息
    ·假设我们需要设计出这样的一个xml文件来存储相应的信息,如下所示:

    复制代码代码如下:


    <Computers>
      <Computer ID="11111111" Description="Made in China">
        <name>Lenovo</name>
        <price>5000</price>
      </Computer>
      <Computer ID="2222222" Description="Made in USA">
        <name>IBM</name>
        <price>10000</price>
      </Computer>
    </Computers>


      那么如何生成这个xml文件?又怎么读取这个xml文件的节点信息,以及如何对这个xml文件的节点信息作相应的操作?请看如下代码示例:
      【注:因为我们要使用xml相关的语法和方法,所以一定要引入命名空间 System.Xml】

    复制代码代码如下:


       using System;
        using System.Collections.Generic;
        using System.Linq;
        using System.Text;
        using System.Xml;

        namespace OperateXML
       {
           class Program
         {
             static void Main(string[] args)
             {
                 try
                 {
                     //xml文件存储路径
                     string myXMLFilePath = "E:\\MyComputers.xml";
                     //生成xml文件
                     GenerateXMLFile(myXMLFilePath);
                     //遍历xml文件的信息
                     GetXMLInformation(myXMLFilePath);
                     //修改xml文件的信息
                     ModifyXmlInformation(myXMLFilePath);
                     //向xml文件添加节点信息
                     AddXmlInformation(myXMLFilePath);
                     //删除指定节点信息
                     DeleteXmlInformation(myXMLFilePath);
                 }
                 catch (Exception ex)
                 {
                     Console.WriteLine(ex.ToString());
                 }
             }

             private static void GenerateXMLFile(string xmlFilePath)
             {
                 try
                 {
                     //初始化一个xml实例
                     XmlDocument myXmlDoc = new XmlDocument();
                     //创建xml的根节点
                     XmlElement rootElement = myXmlDoc.CreateElement("Computers");
                     //将根节点加入到xml文件中(AppendChild)
                     myXmlDoc.AppendChild(rootElement);

                     //初始化第一层的第一个子节点
                     XmlElement firstLevelElement1 = myXmlDoc.CreateElement("Computer");
                     //填充第一层的第一个子节点的属性值(SetAttribute)
                     firstLevelElement1.SetAttribute("ID", "11111111");
                     firstLevelElement1.SetAttribute("Description", "Made in China");
                     //将第一层的第一个子节点加入到根节点下
                     rootElement.AppendChild(firstLevelElement1);
                     //初始化第二层的第一个子节点
                     XmlElement secondLevelElement11 = myXmlDoc.CreateElement("name");
                     //填充第二层的第一个子节点的值(InnerText)
                     secondLevelElement11.InnerText = "Lenovo";
                     firstLevelElement1.AppendChild(secondLevelElement11);
                     XmlElement secondLevelElement12 = myXmlDoc.CreateElement("price");
                     secondLevelElement12.InnerText = "5000";
                     firstLevelElement1.AppendChild(secondLevelElement12);

     
                     XmlElement firstLevelElement2 = myXmlDoc.CreateElement("Computer");
                     firstLevelElement2.SetAttribute("ID", "2222222");
                     firstLevelElement2.SetAttribute("Description", "Made in USA");
                     rootElement.AppendChild(firstLevelElement2);
                     XmlElement secondLevelElement21 = myXmlDoc.CreateElement("name");
                     secondLevelElement21.InnerText = "IBM";
                     firstLevelElement2.AppendChild(secondLevelElement21);
                     XmlElement secondLevelElement22 = myXmlDoc.CreateElement("price");
                     secondLevelElement22.InnerText = "10000";
                     firstLevelElement2.AppendChild(secondLevelElement22);

                     //将xml文件保存到指定的路径下
                     myXmlDoc.Save(xmlFilePath);
                 }
                 catch (Exception ex)
                 {
                     Console.WriteLine(ex.ToString());
                 }
             }

             private static void GetXMLInformation(string xmlFilePath)
             {
                 try
                 {
                     //初始化一个xml实例
                     XmlDocument myXmlDoc = new XmlDocument();
                     //加载xml文件(参数为xml文件的路径)
                     myXmlDoc.Load(xmlFilePath);
                     //获得第一个姓名匹配的节点(SelectSingleNode):此xml文件的根节点
                     XmlNode rootNode = myXmlDoc.SelectSingleNode("Computers");
                     //分别获得该节点的InnerXml和OuterXml信息
                     string innerXmlInfo = rootNode.InnerXml.ToString();
                     string outerXmlInfo = rootNode.OuterXml.ToString();
                     //获得该节点的子节点(即:该节点的第一层子节点)
                     XmlNodeList firstLevelNodeList = rootNode.ChildNodes;
                     foreach (XmlNode node in firstLevelNodeList)
                     {
                         //获得该节点的属性集合
                         XmlAttributeCollection attributeCol = node.Attributes;
                         foreach (XmlAttribute attri in attributeCol)
                         {
                             //获取属性名称与属性值
                             string name = attri.Name;
                             string value = attri.Value;
                             Console.WriteLine("{0} = {1}", name, value);
                         }

                         //判断此节点是否还有子节点
                         if (node.HasChildNodes)
                         {
                             //获取该节点的第一个子节点
                             XmlNode secondLevelNode1 = node.FirstChild;
                             //获取该节点的名字
                             string name = secondLevelNode1.Name;
                             //获取该节点的值(即:InnerText)
                             string innerText = secondLevelNode1.InnerText;
                             Console.WriteLine("{0} = {1}", name, innerText);

                             //获取该节点的第二个子节点(用数组下标获取)
                             XmlNode secondLevelNode2 = node.ChildNodes[1];
                             name = secondLevelNode2.Name;
                             innerText = secondLevelNode2.InnerText;
                             Console.WriteLine("{0} = {1}", name, innerText);
                         }
                     }
                 }
                 catch (Exception ex)
                 {
                     Console.WriteLine(ex.ToString());
                 }
             }

             private static void ModifyXmlInformation(string xmlFilePath)
             {
                 try
                 {
                     XmlDocument myXmlDoc = new XmlDocument();
                     myXmlDoc.Load(xmlFilePath);
                     XmlNode rootNode = myXmlDoc.FirstChild;
                     XmlNodeList firstLevelNodeList = rootNode.ChildNodes;
                     foreach (XmlNode node in firstLevelNodeList)
                     {
                         //修改此节点的属性值
                         if (node.Attributes["Description"].Value.Equals("Made in USA"))
                         {
                             node.Attributes["Description"].Value = "Made in HongKong";
                         }
                     }
                     //要想使对xml文件所做的修改生效,必须执行以下Save方法
                     myXmlDoc.Save(xmlFilePath);
                 }
                 catch (Exception ex)
                 {
                     Console.WriteLine(ex.ToString());
                 }

             }

             private static void AddXmlInformation(string xmlFilePath)
             {
                 try
                 {
                     XmlDocument myXmlDoc = new XmlDocument();
                     myXmlDoc.Load(xmlFilePath);
                     //添加一个带有属性的节点信息
                     foreach (XmlNode node in myXmlDoc.FirstChild.ChildNodes)
                     {
                         XmlElement newElement = myXmlDoc.CreateElement("color");
                         newElement.InnerText = "black";
                         newElement.SetAttribute("IsMixed", "Yes");
                         node.AppendChild(newElement);
                     }
                     //保存更改
                     myXmlDoc.Save(xmlFilePath);
                 }
                 catch (Exception ex)
                 {
                     Console.WriteLine(ex.ToString());
                 }
             }

             private static void DeleteXmlInformation(string xmlFilePath)
             {
                 try
                 {
                     XmlDocument myXmlDoc = new XmlDocument();
                     myXmlDoc.Load(xmlFilePath);
                     foreach (XmlNode node in myXmlDoc.FirstChild.ChildNodes)
                     {
                         //记录该节点下的最后一个子节点(简称:最后子节点)
                         XmlNode lastNode = node.LastChild;
                         //删除最后子节点下的左右子节点
                         lastNode.RemoveAll();
                         //删除最后子节点
                         node.RemoveChild(lastNode);
                     }
                     //保存对xml文件所做的修改
                     myXmlDoc.Save(xmlFilePath);
                 }
                 catch (Exception ex)
                 {
                     Console.WriteLine(ex.ToString());
                 }
             }
         }
     }
     


     上面的这个例子,首先是通过GenerateXMLFile方法在E盘创建出了我们预想的xml文件;然后通过GetXMLInformation方法对刚刚生成的xml文件进行了信息的读取;
    之后通过ModifyXmlInformation方法对xml文件信息作出相应的修改(<Computer ID="2222222" Description="Made in USA">
    修改成为<Computer ID="2222222" Description="Made in HongKong">);再之后通过AddXmlInformation方法向xml文件中添加了一个带有属性值的color节点;
    最后通过DeleteXmlInformation方法将刚刚添加上的color节点删除掉。至此完成了对xml文件的基本操作:创建、读取、修改、添加、删除。
    【注1:想要将对xml文件所做的任何修改生效的话,必须调用Save方法,否则我们所做的修改不会保存】
    【注2:我们在创建节点的时候用的是XmlElement,但是读取节点信息的时候却用的是XmlNode,这里强调一点:XmlElement是XmlNode的继承,可以调用更多的方法
        实现相应所需的功能】
      最后简单集中的总结一下对xml进行操作的基本方法,如下所示:

    复制代码代码如下:


        //所需要添加的命名空间
        using System.Xml;
        //初始化一个xml实例
        XmlDocument xml=new XmlDocument();
        //导入指定xml文件
        xml.Load(“xml文件路径path”);
        //指定一个节点
        XmlNode root=xml.SelectSingleNode("节点名称");
        //获取节点下所有直接子节点
        XmlNodeList childlist=root.ChildNodes;
        //判断该节点下是否有子节点
        root.HasChildNodes;
        //获取同名同级节点集合
        XmlNodeList nodelist=xml.SelectNodes("节点名称");
        //生成一个新节点
        XmlElement node=xml.CreateElement("节点名称");
        //将节点加到指定节点下,作为其子节点
        root.AppendChild(node);
        //将节点加到指定节点下某个子节点前
        root.InsertBefore(node,root.ChildeNodes[i]);
        //为指定节点的新建属性并赋值
        node.SetAttribute("id","11111");
        //为指定节点添加子节点
        root.AppendChild(node);
        //获取指定节点的指定属性值
        string id=node.Attributes["id"].Value;
        //获取指定节点中的文本
        string content=node.InnerText;
        //保存XML文件
        xml.Save(“xml文件存储的路径path”);

    展开全文
  • DOM操作xml数据

    万次阅读 2016-09-08 15:37:41
    xml数据 查询xml 增加xml 修改xml 操作xml属性

    xml数据


    查询xml

    增加xml

    修改xml

    操作xml属性


    展开全文
  • 动态生成Rss文件 Xml操作 Xml文件的修改 简单实用的demo
  • C#操作--修改XML文档

    2009-09-21 07:48:55
    该资源采用C#技术 主要操作为用C#技术修改XML文件 便于保存和阅读 代码简单易懂 方便大家学习
  • asp操作xml,asp对xml进行读写删除修改操作,欢迎来下,自己做的!
  • C#操作xml 含添加 删除 修改电子书 C#操作xml 含添加 删除 修改电子书
  • groovy操作xml,获取属性值和标签值,并将其修改 一、用groovy操作xml,修改xml的值 由于我操作的是plist文件,其中会有IOS的dtd对xml验证,解析的时候会报错,如下: org.xml.sax.SAXParseException; systemId: file:/...

    groovy操作xml,获取属性值和标签值,并将其修改

    一、用groovy操作xml,修改xml的值

    由于我操作的是plist文件,其中会有IOS的dtd对xml验证,解析的时候会报错,如下:

    org.xml.sax.SAXParseException; systemId: file:///Users/guoyf/Desktop/Info.plist; lineNumber: 2; columnNumber: 10; 将功能 "http://apache.org/xml/features/disallow-doctype-decl" 设置为“真”时, 不允许使用 DOCTYPE。

    解决方法参考:点击这里吧

    话不多说,上代码

    import groovy.xml.MarkupBuilder
    import groovy.xml.XmlUtil
    import groovy.xml.*
    import java.io.*
    
    class XmlWriter {
        public static main(def args){
        
            /*关闭解析器的验证,不去下载外部dtd文件来对xml进行验证
            <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
            */
            def parser = new XmlParser();
            parser.setFeature("http://apache.org/xml/features/disallow-doctype-decl",false);
            parser.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd",false);
            
            def file = new File("oa.plist");   
            def config = parser.parse(file);//解析xml文件
            
            //获取xml里面属性为version的值,version="1.0"
            def version = config.attributes().get("version");//1.0
            def dict = config.dict;
    
            config.attributes().put("version","123");//将属性值"1.0"改为"123"
            
            //打印属性为name的值,name="云办公呀呀呀"
            println config.attributes().get("name");//云办公呀呀呀
    //        println "${config.attribute('version')}"
            println config.dict.array.dict.array.dict[0].string[1].text();//获取标签值并打印
            
            
            //修改标签值
            config.dict.array.dict.array.dict[0].string[1].value()[0] = "123456"
            
            
            
            
            def xmlFile = "configNewToString.xml";
            //用UTF-8写入,默认为GBK,不然会有乱码
            PrintWriter pw = new PrintWriter(xmlFile,("UTF-8"));
    //        PrintWriter pw = new PrintWriter(xmlFile,("GBK"));
            pw.write(XmlUtil.serialize(config));//用XmlUtil.serialize方法,将String改为xml格式
            pw.close();
            
            
            }
        }

    附上我要解析的plist源文件即oa.plist:

    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
    <plist version="1.0" name="云办公呀呀呀">
    <dict>
    	<key>items</key>
    	<array>
    		<dict>
    			<key>assets</key>
    			<array>
    				<dict>
    					<key>kind</key>
    					<string>software-package</string>
    					<key>url</key>
    					<string>https://version.geshuinfo.cn:4444/sys/sysAttachment/download?pkid=65d2038e505a432da323f91f409e81ef</string>
    				</dict>
    				<dict>
    					<key>kind</key>
    					<string>display-image</string>
    					<key>needs-shine</key>
    					<true/>
    					<key>url</key>
    					<string>http://ming.pactera.com/mingwebApp/app/logo.5757.png</string>
    				</dict>
    				<dict>
    					<key>kind</key>
    					<string>full-size-image</string>
    					<key>md5</key>
    					<string>baae4e9499e9b29c2420ad8a002f33c2</string>
    					<key>needs-shine</key>
    					<true/>
    					<key>url</key>
    					<string>http://ming.pactera.com/mingwebApp/app/logo.512512.jpg</string>
    				</dict>
    			</array>
    			<key>metadata</key>
    			<dict>
    				<key>bundle-identifier</key>
    				<string>com.chinazw.community</string>
    				<key>bundle-version</key>
    				<string>1.1.0</string>
    				<key>kind</key>
    				<string>software</string>
    				<key>subtitle</key>
    				<string>OA</string>
    				<key>title</key>
    				<string>OA</string>
    			</dict>
    		</dict>
    	</array>
    </dict>
    </plist>

    然后是通过PrintWriter写入的configNewToString.xml文件,其实这个你可以用和源文件同名的oa.plst这样就能覆盖源文件达到更新的标准了,我的生成文件如下:

    <?xml version="1.0" encoding="UTF-8"?><plist version="123" name="云办公呀呀呀">
      <dict>
        <key>items</key>
        <array>
          <dict>
            <key>assets</key>
            <array>
              <dict>
                <key>kind</key>
                <string>software-package</string>
                <key>url</key>
                <string>123456</string>
              </dict>
              <dict>
                <key>kind</key>
                <string>display-image</string>
                <key>needs-shine</key>
                <true/>
                <key>url</key>
                <string>http://ming.pactera.com/mingwebApp/app/logo.5757.png</string>
              </dict>
              <dict>
                <key>kind</key>
                <string>full-size-image</string>
                <key>md5</key>
                <string>baae4e9499e9b29c2420ad8a002f33c2</string>
                <key>needs-shine</key>
                <true/>
                <key>url</key>
                <string>http://ming.pactera.com/mingwebApp/app/logo.512512.jpg</string>
              </dict>
            </array>
            <key>metadata</key>
            <dict>
              <key>bundle-identifier</key>
              <string>com.chinazw.community</string>
              <key>bundle-version</key>
              <string>1.1.0</string>
              <key>kind</key>
              <string>software</string>
              <key>subtitle</key>
              <string>OA</string>
              <key>title</key>
              <string>OA</string>
            </dict>
          </dict>
        </array>
      </dict>
    </plist>
    

    是不是觉得少了点啥?对的,就是少了

    <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">

    这个验证我们解析的时候被关闭了,你可以当做给删除了。是不是很恼火,正常的xml到此就可以结束了,可是IOS的plist需要它来验证,这个时候你就不能用解析xml的方法来改值了,下面我提供一个操作文件的方法来改值

    二、操作文件来改值

    代码不多,要改的地方按你的需求用正则来写就可以了,代码如下:

    //原始文件
    def filePath = "oa.plist"
    def file = new File(filePath)
    
    //临时文件
    def tempFilePath = "oa1.plist"
    def tempFile = new File(tempFilePath)
    //以"UTF-8"来写入,不然有汉字乱码的问题,默认为GBK
    def out = tempFile.newPrintWriter("UTF-8")
    
    
    def lineNum = 1
    def newLine = ""
    
    file.eachLine ("UTF-8"){
    
        if (lineNum>2){
            //前两行不做处理,只处理后面的内容
            it = it.replace("version=\"1.0\"","version=\"2.0\"")
        }
    
        //写入
        out.println(it);
        lineNum++
    }
    
    //完成写入
    out.flush()
    out.close()

    以上就我是用来修改xml值的方法,android小白,有大神话还望指教!!!!!!!!!!

    展开全文
  • JDOM提供了非常灵活的方式操作XML文件,使用JDOM非常简单而且代码简洁可读性强。前面我们学习了如何使用JDOM解析XML文件,本节介绍如何使用JDOM修改XML文件内容。 在这个教程中,我们准备对下面的XML文件进行修改:...
  • 使用XmlDocument操作XML进行查询、增加、修改、删除、保存应用的实例.
  • 主要介绍了通过php修改xml文档内容的方法,涉及php针对XML节点的赋值与保存操作,需要的朋友可以参考下
  • C#操作XMl 三种方法 包括对读取XML 数据对数据库操作、修改XML 节点等
  • JDOM 操作xml 解析读取xml文件 修改 删除 增添xml指定节点信息的XmlBean
  • jsp操作xml数据库

    2013-08-29 15:25:03
    jsp处理xml数据库,操作xml文件,实现对xml文件的增删修改。大三的xml课程设计,附带源代码和xml数据库文件。初学者可以借鉴参考
  • C#操作XML文档的详解

    2019-01-11 10:53:16
    C#操作XML,添加,删除,修改,调用XML内容,很方便。
  • linq 操作xmldemo

    2013-12-23 16:07:42
    通过linq来操作xml,实现创建,修改,增加,删除xml节点的操作,并在gridview上展现
  • PowerShell 操作 xml

    千次阅读 2014-12-07 09:43:33
    PowerShell作为优秀的服务器管理...PowerShell 如果希望将 xml 仅仅作为普通的文档处理,只需要使用 Get-Content 命令即可,但是如果系统将 xml 文件作为 xml 来处理(使用操作 xml)的方法,那么我们就需要使用 Get-C
  • QT QTreewidget显示和修改xml文件并导出
  • QT修改XML文件

    千次阅读 2020-04-29 16:07:49
    本例主要讲解XML结点的小知识,已经提供QT修改XML文件内容的小例子 二、XML结点知识 例如有个test.xml文件如下: <?xml version="1.0" encoding="UTF-8"?> <rootName> <node1Name1> ...
  • Go操作XML

    千次阅读 2017-04-28 14:24:41
    xml包提供了两种方式来操作XML,一种是高阶的方式,一种是低阶的方式。高阶的方式提供了Marshal和Unmarshal两个函数分别来编码(将Go数据结构转换成XML)和解码(将XML转换成Go数据结构)。低阶的方法则基于token来...
  • android操作xml

    千次阅读 2013-05-03 16:15:51
    android操作xml封装后的类,包括创建xml和读xml。 public class XmlParserUtil { //创建xml文件 public static void createXmlFile(final String xmlPath) { File xmlFile = new File(xmlPath); ...
  • C#中操作xml文件(插入节点、修改、删除).htmC#中操作xml文件(插入节点、修改、删除).htmC#中操作xml文件(插入节点、修改、删除).htmC#中操作xml文件(插入节点、修改、删除).htmC#中操作xml文件(插入节点、...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,848,653
精华内容 739,461
关键字:

修改xml