// 创建一个xml文档  XDocument所属命名空间：using System.Xml.Linq;
            XDocument xDoc = new XDocument();
            // 添加根节点
            XElement xRoot = new XElement("Root");
            // 添加节点使用Add
            xDoc.Add(xRoot);

            // 创建一个学生加到root中
            // 1、创建学生节点
            XElement xStudent = new XElement("Student");

            // 2、创建学生姓名、年龄、性别
            XElement xName = new XElement("Name");
            XElement xAge = new XElement("Age");
            XElement xGender = new XElement("Gender");

            //给每个元素赋值
            xName.Value = "张三";
            xAge.Value = "19";
            xGender.Value = "男";

            // 3、添加节点(没有顺序之分)
            xStudent.Add(xName, xAge, xGender);  //把学生姓名，年龄，性别元素添加到学生节点下
            xRoot.Add(xStudent);    //把学生节点添加到根节点下

            // 为Student添加属性
            XAttribute xId = new XAttribute("id", ".Net01");
            xStudent.Add(xId);

            // 保存该文档  
            xDoc.Save("myxml.xml");

<?xml version="1.0" encoding="utf-8"?>
<Root>
  <Student id=".Net01">
    <Name>张三</Name>
    <Age>19</Age>
    <Gender>男</Gender>
  </Student>
</Root>

　　static void saveXml2()
        {
            //如果你喜欢这样写的话，那就一级一级阶梯状排列好。很有层次感，看起来特明了
            XDocument xDoc = new XDocument(
               new XElement("Root",
                    new XElement("FlyInfo",
                        new XElement("Sum",
                            new XElement("AirLine", "航空"),
                            new XElement("Seat", "经济舱"),
                            new XElement("Rating", "A"),
                            new XElement("Gai", "可以改"),
                            new XElement("Tui", "可以退"),
                            new XElement("Qian", "可以签"),
                            new XElement("com",
                                new XElement("comm", "暂无")
                            )
                        )
                    ),

                    new XElement("FlyInfo",
                        new XElement("Sum",
                            new XElement("AirLine", "航空"),
                            new XElement("Seat", "头等舱"),
                            new XElement("Rating", "R"),
                            new XElement("Gai", "不可以改"),
                            new XElement("Tui", "不可以退"),
                            new XElement("Qian", "不可以签")
                        )
                    )
                )
            );

            xDoc.Save("Test.xml"); 
        }

 　　static void saveXMLs()
        {
            XDocument xDoc = new XDocument();  //实例化一个xml(内容)文档
            XElement xRoot = new XElement("Root");  //创建一个xml根节点
            xDoc.Add(xRoot);  //把根节点添加到xml文档  记住：一个xml文档只能有一个根节点，可以多个父节点。多个子节点，可以把任何一个元素作为父节点或子节点

            //以下均是xml元素  FlyInfo元素(父节点)下又有子元素(子节点)  如果把一个学校(根节点) 很多个教室(父节点)  每个班级的学生(子节点)就是所属班级(父节点)的子节点
            XElement xFlyInfo = new XElement("FlyInfo");  //
            XElement xAirLine = new XElement("AirLine");
            XElement xSeat = new XElement("Seat");
            XElement xRating = new XElement("Rating");
            XElement xGai = new XElement("Gai");
            XElement xTui = new XElement("Tui");
            XElement xQian = new XElement("Qian");

            xAirLine.Value = "航空";
            xSeat.Value = "经济舱";
            xRating.Value = "A";
            xGai.Value = "可以改";
            xTui.Value = "可以退";
            xQian.Value = "可以签";


            xRoot.Add(xAirLine, xSeat, xRating, xGai, xTui, xQian);  //把元素添加到根节点中

            xDoc.Save("test.xml"); //保存xml文档
        }

　　 static void saveDtable()
        {
            DataSet ds = new DataSet("Root"); //实例化一个DataSet 并初始化值为Root，映射到xml时则是根节点，当没初始化值时。默认是NewDataSet  

            DataTable table = new DataTable("FlyInfo"); //实例化一个table。同时取名为FlyInfo。当映射到xml文档时则是xml文档中的一个父节点,table必须指定表名，因为它可没有默认值。
            //table.TableName = "FlyInfo";  //如果初始化没设置表名，可以通过属性设置。也OK

            //给Table添加列，映射到xml文档时是当前父节点的子节点
            table.Columns.Add("AirLine");
            table.Columns.Add("Seat");
            table.Columns.Add("Rating");
            table.Columns.Add("Gai");
            table.Columns.Add("Tui");
            table.Columns.Add("Qian");

            //创建与该表具有相同架构的新行
            DataRow dr = table.NewRow();

            //添加数据
            dr["AirLine"] = "航空";
            dr["Seat"] = "经济舱";
            dr["Rating"] = "A";
            dr["Gai"] = "可以改";
            dr["Tui"] = "可以退";
            dr["Qian"] = "可以签";

            table.Rows.Add(dr); //把每一行添加到table

            //以下两句效果相同
            ds.Tables.Add(table); //把table添加到DataSet(数据集)中
            //ds.Tables.Add(table.Copy()); //这样也行，复制当前表格的数据和结构，然后添加到DataSet中

            ds.WriteXml("tableDemo.xml");  //保存咯

            //下面都是清除数据，释放资源 
            //dt.Rows[0].Delete(); 删除某一行
            //dt.AcceptChanges(); 返回删除后的数据
            ds.Clear();
            ds.Tables.Clear();
        }

<?xml version="1.0" standalone="yes"?>
<Root>
  <FlyInfo>
    <AirLine>航空</AirLine>
    <Seat>经济舱</Seat>
    <Rating>A</Rating>
    <Gai>可以改</Gai>
    <Tui>可以退</Tui>
    <Qian>可以签</Qian>
  </FlyInfo>
</Root>

　　　　　　 //XDocument提供了Load()静态方法
            XDocument xDoc = XDocument.Load("tableDemo.xml"); //加载xml文档。这里是相对路径
　　　　　　//当你生了个儿子。想上户口簿时，就给其父亲加个儿子节点
            XElement xfa = xDoc.Root.Element("FlyInfo");  //找到父亲（FlyInfo是父节点，所属他下面的都是子节点）
            XNode xson = xfa.LastNode; //找到最后一个儿子节点

            //这里给父亲添加个儿子(在末尾添加的)
            xson.AddAfterSelf(
                 new XElement("son","还没生子") //这里son没有儿子。也就是son节点没有子节点
                );
 　　　　　xDoc.Save("tableDemo.xml"); //保存数据  其实总的来说是把全部数据读到内存中然后在内存中追加数据后再全部保存tableDemo.xml

<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<Root>
  <FlyInfo>
    <AirLine>航空</AirLine>
    <Seat>经济舱</Seat>
    <Rating>A</Rating>
    <Gai>可以改</Gai>
    <Tui>可以退</Tui>
    <Qian>可以签</Qian>
    <son>还没生子</son>
  </FlyInfo>
</Root>

XElement i = xDoc.Root.Element("FlyInfo").Element("Seat"); //父节点(FlyInfo)下的子节点(Seat)

            //这里给父亲添加个儿子(在末尾添加的) 在之前添加用：AddBeforeSelf
            i.AddAfterSelf(
                 new XElement("Info","详细信息") //这里Info没有儿子。也就是Info节点没有子节点
                );

            xDoc.Save("tableDemo.xml");

<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<Root>
  <FlyInfo>
    <AirLine>航空</AirLine>
    <Seat>经济舱</Seat>
    <Info>详细信息</Info>
    <Rating>A</Rating>
    <Gai>可以改</Gai>
    <Tui>可以退</Tui>
    <Qian>可以签</Qian>
  </FlyInfo>
</Root>

XElement i = xDoc.Root.Element("FlyInfo").Element("Rating"); //父节点(FlyInfo)下的子节点(Rating)

            i.Add(new XAttribute("name", "mark"));
 xDoc.Save("tableDemo.xml");

<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<Root>
  <FlyInfo>
    <AirLine>航空</AirLine>
    <Seat>经济舱</Seat>
    <Rating name="mark">A</Rating>
    <Gai>可以改</Gai>
    <Tui>可以退</Tui>
    <Qian>可以签</Qian>
  </FlyInfo>
</Root>

IEnumerable<XNode> atr = xDoc.Root.Element("FlyInfo").Nodes();  //找到FlyInfo节点下所有子节点

            foreach (XElement item in atr)  //遍历节点
            {
                if (item.Attribute("name") != null) //不为null说明找到了有name属性的节点，拆开写的话： XAttribute at = item.Attribute("name"); 然后if(at!=null){...}
                {
                    item.AddAfterSelf(
                            new XElement("attr","根据属性查找节点并添加")
                        );
                }
            }
            xDoc.Save("tableDemo.xml");

<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<Root>
  <FlyInfo>
    <AirLine>航空</AirLine>
    <Seat>经济舱</Seat>
    <Rating name="mark">A</Rating>
    <attr>根据属性查找节点并添加</attr>
    <Gai>可以改</Gai>
    <Tui>可以退</Tui>
    <Qian>可以签</Qian>
  </FlyInfo>
</Root>

 //创建一个xml文档
            XmlDocument xmlDoc = new XmlDocument();

            //定义xml声明，XmlDoxument跟XDocument不同，默认没有声明，
            XmlDeclaration xmlDec = xmlDoc.CreateXmlDeclaration("1.0", "GB2312", "yes");
            xmlDoc.AppendChild(xmlDec);

            //创建一个根节点
            XmlElement xmlRoot = xmlDoc.CreateElement("Root");

            //把根节点添加到xml文档
            xmlDoc.AppendChild(xmlRoot);

            //创建学生节点
            XmlElement xmlStudent = xmlDoc.CreateElement("Student");

            //创建学生姓名，年龄,性别
            XmlElement xmlName = xmlDoc.CreateElement("Name");
            XmlElement xmlAge = xmlDoc.CreateElement("Age");
            XmlElement xmlGender = xmlDoc.CreateElement("Gender");

            //赋值
            xmlName.InnerText = "张三";
            xmlAge.InnerText = "20";
            xmlGender.InnerText = "男";

            //当然。你喜欢的话，可以添加属性
            XmlAttribute xId = xmlDoc.CreateAttribute("id");
            xId.Value = ".Net01";
            xmlStudent.SetAttributeNode(xId);

            //添加节点
            xmlStudent.AppendChild(xmlName);
            xmlStudent.AppendChild(xmlAge);
            xmlStudent.AppendChild(xmlGender);

            xmlRoot.AppendChild(xmlStudent);

            //保存xml文档
            xmlDoc.Save("xmlDocument.xml");

<?xml version="1.0" encoding="GB2312" standalone="yes"?>
<Root>
  <Student id=".Net01">
    <Name>张三</Name>
    <Age>20</Age>
    <Gender>男</Gender>
  </Student>
</Root>

<?xml version="1.0" encoding="utf-8"?>
<Root>
  <FlyInfo>
    <AirLine>航空</AirLine>
    <Seat>经济舱</Seat>
    <Rating>A</Rating>
    <Gai>可以改</Gai>
    <Tui>可以退</Tui>
    <Qian>可以签</Qian>
  </FlyInfo>
</Root>

static void xmlDocu()
        {
            //实例化一个XmlDocument文档
            XmlDocument xmlDoc = new XmlDocument();
            //加载xml文档
            xmlDoc.Load("xmlDoumer.xml");

            //ChildNodes[0]这是找到第一个,树结构一样。找谁都行。当然要保证有咯
            XmlNode node = xmlDoc.DocumentElement.ChildNodes[0].CloneNode(true);  //因为是添加具有相同节点树结构，所有找到一个树结构，创建副本，即克隆

            //以下是获取父节点下的子节点  这里更改了每个子元素的内容。如果你不更改。默认值还是原来的值
            node["AirLine"].InnerText = "北京航空";
            node["Seat"].InnerText = "头等舱";
            node["Rating"].InnerText = "AB";
            node["Gai"].InnerText = "不改";
            node["Tui"].InnerText = "不退";
            node["Qian"].InnerText = "不签";
           
            //在根节点下最后一个子元素末尾添加
            xmlDoc.DocumentElement.AppendChild(node);
            xmlDoc.Save("xmlDoumer.xml"); //保存
        }

<?xml version="1.0" encoding="utf-8"?>
<Root>
  <FlyInfo>
    <AirLine>航空</AirLine>
    <Seat>经济舱</Seat>
    <Rating>A</Rating>
    <Gai>可以改</Gai>
    <Tui>可以退</Tui>
    <Qian>可以签</Qian>
  </FlyInfo>
  <FlyInfo>
    <AirLine>北京航空</AirLine>
    <Seat>头等舱</Seat>
    <Rating>AB</Rating>
    <Gai>不改</Gai>
    <Tui>不退</Tui>
    <Qian>不签</Qian>
  </FlyInfo>
</Root>

static void xmlDocu()
        {
            //实例化一个XmlDocument文档
            XmlDocument xmlDoc = new XmlDocument();
            //加载xml文档
            xmlDoc.Load("xmlDoumer.xml");

            //ChildNodes[0]这是找到第一个,树结构一样。找谁都行。当然要保证有咯
            XmlNode node = xmlDoc.DocumentElement.ChildNodes[0].CloneNode(true);  //因为是添加具有相同节点树结构，所有找到一个树结构，创建副本，即克隆

            //以下是获取父节点下的子节点  这里更改了每个子元素的内容。如果你不更改。默认值还是原来的值
            node["AirLine"].InnerText = "北京航空";
            node["Seat"].InnerText = "头等舱";
            node["Rating"].InnerText = "AB";
            node["Gai"].InnerText = "不改";
            node["Tui"].InnerText = "不退";
            node["Qian"].InnerText = "不签";
           
  //修改属性：很显然要保证子节点有属性。同样 (当然这也是你百分百确定有这个属性)
            //node["AirLine"].Attributes["id"].Value = "90";
            //当然，如果你不想要这个元素 就干掉
            //node.RemoveChild(node["Qian"]);

 //创建一个子节点的两种方式
            XmlElement addNode = xmlDoc.CreateElement("Phone");
            XmlNode xno = xmlDoc.CreateNode(XmlNodeType.Element, "link", null);

            //给元素赋值
            xno.InnerText = "新来的Node";
            addNode.InnerText = "15858585588"; 

            //把节点添加到末尾
            node.AppendChild(xno);
            node.AppendChild(addNode); 


            //在根节点下最后一个子元素末尾添加
            xmlDoc.DocumentElement.AppendChild(node);
            xmlDoc.Save("xmlDoumer.xml"); //保存
        }

<?xml version="1.0" encoding="utf-8"?>
<Root>
  <FlyInfo>
    <AirLine>航空</AirLine>
    <Seat>经济舱</Seat>
    <Rating>A</Rating>
    <Gai>可以改</Gai>
    <Tui>可以退</Tui>
    <Qian>可以签</Qian>
  </FlyInfo>
  <FlyInfo>
    <AirLine>北京航空</AirLine>
    <Seat>头等舱</Seat>
    <Rating>AB</Rating>
    <Gai>不改</Gai>
    <Tui>不退</Tui>
    <Qian>不签</Qian>
    <link>新来的Node</link>
    <Phone>15858585588</Phone>
  </FlyInfo>
</Root>

/// <summary>
        /// linq to xml--读取xml文档
        /// </summary>
        public static void ReadXML()
        {

            XDocument xDoc = XDocument.Load("Student.xml");  //加载xml文档，(相对路劲)

            /*这里用Descendants(xName)的好处是可以跨层次，跨节点，而不像Element
              比如要找到所有的Student节点。
              Element： xDoc.Element("Root").Elements()  这里必须是从根节点到子节点一级一级找。
              Descendants:xDoc.Descendants("Student")  跨了 根节点 Root 直接在根节点下找
            */
            var E1 = from item in xDoc.Descendants("Student")  //找到所有Student元素
                     select item;

            E1.ToList().ForEach(it => Console.WriteLine(it));

            Console.WriteLine("-----------分割线1-----------");

            //找到学生属性Id=1的学生。显示学生姓名和年龄
            var E2 = from item in xDoc.Descendants("Student")
                     where item.Attribute("Id").Value == "1"
                     select new
                     {
                         name = item.Element("name").Value,
                         age = item.Element("age").Value
                     };
            E2.ToList().ForEach(it => Console.WriteLine(string.Format("姓名：{0},年龄：{1}", it.name, it.age)));

            Console.WriteLine("-----------分割线2-----------");

            //如果学生Id=1有多个，而你只想显示第一个。则用FirstOrDefault(),返回满足条件的第一个元素
            var E3 = (from item in xDoc.Descendants("Student")
                      where item.Attribute("Id").Value == "1"
                      select new
                      {
                          name = item.Element("name").Value,
                          age = item.Element("age").Value
                      }).FirstOrDefault();

            //因为此时返回的结果已不是集合，可直接输出
            Console.WriteLine("姓名为：" + E3.name + "年龄为：" + E3.age);

            Console.WriteLine("-----------分割线3-----------");

            //显示所有学生的姓名和年龄
            var E4 = from item in xDoc.Descendants("Student")
                     select new
                     {
                         name = item.Element("name").Value,
                         age = item.Element("age").Value
                     };
            E4.ToList().ForEach(it => Console.WriteLine(string.Format("姓名：{0},年龄为：{1}", it.name, it.age)));

            //以上仅仅是举了些简单的例子，实际中还得根据需要灵活运用。记住。xml是区分大小写的。所以要注意属性名和元素名的大小写要一致

        }

/// <summary>
        ///  linq to xml--编辑xml文档
        /// </summary>
        public static void EditXML()
        {
            XDocument xDoc = XDocument.Load("Student.xml"); //加载xml文档

            //现在你发现学生的姓名和年龄不能满足需求，需要添加一个性别信息 ，那就得添加一个元素<sex>male</sex>
            var E5 = from item in xDoc.Descendants("Student")  //找到所有（元素名为Student）学生节点
                     select item;

            E5.ToList().ForEach(it => it.SetElementValue("sex", "male")); //当然。这是给所有的学生都添加性别为male
            xDoc.Save(Console.Out); //这里为了方便查看修改后的内容。输出到控制台看结果，此时是在内存中。并没有保存到磁盘  下同

            Console.WriteLine("-----------分割线1-----------");

            //这是把第一个学生为mail 第二个学生为female
            foreach (var item in E5)
            {
                if (item.Attribute("Id").Value.Equals("1"))
                    item.SetElementValue("sex", "male");
                else
                    item.SetElementValue("sex", "female");
            }
            xDoc.Save(Console.Out);

            Console.WriteLine("-----------分割线2-----------");

            //知道添加元素了。现在你添加一个学生也是如此简单，班级来了个插班生。需添加第三个学生，多加一张课桌
            var E6 = from item in xDoc.Descendants("Root")  //找到根节点(班级)下所有的（学生）的元素
                     select item;

            //先拼好要添加的元素
            var content = new XElement("Student",
                              new XAttribute("Id", "3"),
                              new XElement("name", "Jack"),
                              new XElement("age", "22"),
                              new XElement("sex", "gay")
                            );

            E6.ToList().ForEach(it => it.LastNode.AddAfterSelf(content)); //在最后一个（学生）节点后添加新（座位）元素
            xDoc.Save(Console.Out);

            Console.WriteLine("-----------分割线3-----------");

            //当发现学生Id=1的学生姓名不能是英文。需修改成中文
            var E7 = from item in xDoc.Descendants("Student")
                     where item.Attribute("Id").Value.Equals("1")
                     select item;

            //找到name元素，修改value。同理。修改age一样。。扩展：SetAttributeValue(name,value)添加属性
            E7.ToList().ForEach(it => it.Element("name").SetValue("汤姆"));
            xDoc.Save(Console.Out);
            Console.WriteLine("-----------分割线4-----------");

            //当汤姆退学。需删除元素（课桌）
            var E18 = from item in xDoc.Descendants("Student")
                      where item.Element("name").Value.Equals("汤姆")  //找到汤姆这个学生
                      select item;

            //删除满足条件的节点（同学）,最后只剩下id=2和id=3的节点（学生） 以下三句效果相同
            E18.Remove();
            //E8.ToList().ForEach(it => it.Element("name").Parent.Remove());  
            //E8.ToList().ForEach(it => it.Element("age").Parent.Remove());
            xDoc.Save(Console.Out);

            //记住：1、一个xml文档（XDocument）只能有一个跟节点（Root），文档中不能有相同的元素名（XElement），如果你添加相同的XElement。会覆盖之前的value

            //xDoc.Save("Student.xml"); //保存修改后内容：这里是把xml加载到内存。在内存中修改后再保存到磁盘的。这里保存名不一定是 Student.xml 名字可以随便取。跟之前的Student.xml已经没有任何关系。
        }

 /// <summary>
    /// 序列化与反序列化帮助类--XMLHelper
    /// </summary>
    public class XmlHelper
    {
        /// <summary>
        /// serializer
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="obj">要序列化的实例</param>
        public static void serializeToXml<T>(T obj)
        {
            XmlSerializer serialize = new XmlSerializer(typeof(T));
            using (XmlTextWriter xtw = new XmlTextWriter("Info.xml", Encoding.Default))
                serialize.Serialize(xtw, obj);
        }
        /// <summary>
        /// Deserialize
        /// </summary>
        /// <typeparam name="T">泛型-反序列化后的类型</typeparam>
        /// <param name="data">反序列化的xml文档</param>
        /// <returns></returns>
        public static T DeserializerXml<T>(string data)
        {
            XmlSerializer Deserializer = new XmlSerializer(typeof(T));
            using (XmlTextReader xtr = new XmlTextReader(data))
                return (T)Deserializer.Deserialize(xtr);
        }
    }

 /// <summary>
    /// 实体类序列化
    /// </summary>
    [Serializable]
    [XmlRoot("Root")] //这表明序列化xml文档时。自定义节点名
    public class Person
    {
        //[XmlIgnore] //此字段不序列化
        public string name { get; set; }
        public int age { get; set; }
    }
    /// <summary>
    /// 集合类序列化
    /// </summary>
    public class Persons
    {
        public List<Person> data { get; set; }
    }

static void Main(string[] args)
        {
            Person ps = new Person() { name = "李四", age = 20 };

            #region 实体类的序列化和反序列化
            XmlHelper.serializeToXml(ps);
            Person p = XmlHelper.DeserializerXml<Person>("Info.xml");
            Console.WriteLine("实体类反序列化结果：");
            Console.WriteLine("姓名：" + p.name + "年龄：" + p.age);
            #endregion
            Console.WriteLine("---------分割线-------");
            #region 集合类的序列化和反序列化
            Persons pos = new Persons() { data = new List<Person> { ps } };
            //pos.data = new List<Person>() { ps };
            XmlHelper.serializeToXml(pos);
            Persons po = XmlHelper.DeserializerXml<Persons>("Info.xml");
            Console.WriteLine("集合类反序列化结果：");
            po.data.ForEach(item => Console.WriteLine("姓名：" + item.name + "年龄：" + item.age));
            #endregion
        }

  <?xml version="1.0" encoding="gb2312" ?>
  <Root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
     <name>李四</name> 
     <age>20</age> 
  </Root>