C# LINQ学习笔记五：LINQ to XML

    本笔记摘抄自：https://www.cnblogs.com/yaozhenfa/p/CSharp_Linq_For_Xml.html，记录一下学习过程以备后续查用。

    一、生成xml

    1.1创建简单的xml

    /// <summary>
    /// CreateXml类
    /// </summary>
    public class CreateXml
    {
        /// <summary>
        /// 返回xml文件路径
        /// </summary>
        public string Path
        {
            get
            {
                string path = @"....LinqToXml.xml";
                return path;
            }
        }

        /// <summary>
        /// 创建简单的xml并保存
        /// </summary>
        public void CreateElement()
        {
            XDocument xdoc = new XDocument
                (
                    //创建一个xml文档
                    //设置该xml的版本为1.0，采用utf - 8编码，后面的yes表示该xml是独立的。
                    new XDeclaration("1.0", "utf-8", "yes"),
                    //开始创建每个节点的，首先是Root节点，然后在Root节点中添加两个Item节点。
                    new XElement
                    (
                        "Root",
                        new XElement("Item", "1"),
                        new XElement("Item", "2")
                    )
                );
            xdoc.Save(Path);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            #region 创建简单的xml
            CreateXml xml = new CreateXml();
            xml.CreateElement();
            #endregion
        }
    }

    最终生成的xml如下所示：

<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<Root>
  <Item>1</Item>
  <Item>2</Item>
</Root>

    1.2创建xml注释

    当xml有很多项时，我们就需要利用注释加以区别，通过linq to xml我们一样可以在其中添加注释。

    /// <summary>
    /// CreateXml类
    /// </summary>
    public class CreateXml
    {
        /// <summary>
        /// 返回xml文件路径
        /// </summary>
        public string Path
        {
            get
            {
                string path = @"....LinqToXml.xml";
                return path;
            }
        }

        /// <summary>
        /// 创建xml注释
        /// </summary>
        public void CreateComment()
        {
            XDocument xdoc = new XDocument
                (
                    new XDeclaration("1.0", "utf-8", "yes"),
                    new XComment("这里是注释"),
                    new XElement
                        (
                            "Root",
                            new XElement("Item", "1"),
                            new XElement("Item", "2")
                        )
                );
            xdoc.Save(Path);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ 创建xml注释
            CreateXml xml = new CreateXml();
            xml.CreateComment();
            #endregion
        }
    }

    最终生成的xml如下所示：

<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<!--这里是注释-->
<Root>
  <Item>1</Item>
  <Item>2</Item>
</Root>

    1.3根据对象创建xml

    很多时候我们都会将数组之类的类型转换成xml以便保存进永久性存储介质中。

    /// <summary>
    /// CreateXml类
    /// </summary>
    public class CreateXml
    {
        /// <summary>
        /// 返回xml文件路径
        /// </summary>
        public string Path
        {
            get
            {
                string path = @"....LinqToXml.xml";
                return path;
            }
        }

        /// <summary>
        /// 根据对象创建xml并保存
        /// </summary>
        public void CreateElementByObjects()
        {
            var objs = Enumerable.Range(1, 6);
            XElement xe = new XElement
                (
                    "Root",
                    from obj in objs
                    select new XElement("Item", obj.ToString())
                );
            xe.Save(Path);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ 根据对象创建xml
            CreateXml xml = new CreateXml();
            xml.CreateElementByObjects();
            #endregion
        }
    }

    最终生成的xml如下所示：

<?xml version="1.0" encoding="utf-8"?>
<Root>
  <Item>1</Item>
  <Item>2</Item>
  <Item>3</Item>
  <Item>4</Item>
  <Item>5</Item>
  <Item>6</Item>
</Root>

    1.4创建xml属性

    有时我们不想创建新的子项去保存数据，而是使用属性的方式去保存。理所应当，linq to xml一样也支持这个功能，下面我们可以通过简单的语句去

实现它。

    /// <summary>
    /// CreateXml类
    /// </summary>
    public class CreateXml
    {
        /// <summary>
        /// 返回xml文件路径
        /// </summary>
        public string Path
        {
            get
            {
                string path = @"....LinqToXml.xml";
                return path;
            }
        }

        /// <summary>
        /// 创建xml属性
        /// </summary>
        public void CreateAttribute()
        {
            XAttribute xa = new XAttribute("V2", "2");
            XElement xe = new XElement
                (
                    "Root",
                    new XElement
                        (
                            "Item",
                            new XAttribute("V1", "1"),
                            xa
                        )
                );
            xe.Save(Path);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ 创建xml属性
            CreateXml xml = new CreateXml();
            xml.CreateAttribute();
            #endregion
        }
    }

    最终生成的xml如下所示：

<?xml version="1.0" encoding="utf-8"?>
<Root>
  <Item V1="1" V2="2" />
</Root>

    1.5创建xml命名空间

    对于一些企业级的xml格式，会非常的严格，特别是在同一个xml中可能会出现重复的项，但是我们又想区分开来，这个时候我们可以利用命名空间将

他们分开（跟C#中的命名空间类似）。

    /// <summary>
    /// CreateXml类
    /// </summary>
    public class CreateXml
    {
        /// <summary>
        /// 返回xml文件路径
        /// </summary>
        public string Path
        {
            get
            {
                string path = @"....LinqToXml.xml";
                return path;
            }
        }

        /// <summary>
        /// 创建xml命名空间
        /// </summary>
        public void CreateNamespace()
        {
            XElement xe = new XElement
                (
                    "{http://www.xamarin-cn.com/}Root",
                    new XElement("Item", "1"),
                    new XElement("{http://www.baidu.com/}Item", 2)
                );
            xe.Save(Path);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ 创建xml命名空间
            CreateXml xml = new CreateXml();
            xml.CreateNamespace();
            #endregion
        }
    }

    最终生成的xml如下所示：

<?xml version="1.0" encoding="utf-8"?>
<Root xmlns="http://www.xamarin-cn.com/">
  <Item xmlns="">1</Item>
  <Item xmlns="http://www.baidu.com/">2</Item>
</Root>

    从这个结果中我们可以看到对应的属性中有了xmlns属性，并且值就是我们赋给它的命名空间。

    二、查询并修改Xml

    linq to xml不仅创建xml简单，在查询、编辑和删除方面也一样是非常方便的。

    创建一个XmlReadWrite.xml文件：

<?xml version="1.0" encoding="utf-8"?>
<Root>
  <Item v1="1" v2="2">Item1</Item>
  <Item v1="1" v2="2">Item2</Item>
</Root>

    2.1读取xml文件

    /// <summary>
    /// QueryXml类
    /// </summary>
    public class QueryXml
    {
        /// <summary>
        /// 返回xml文件路径
        /// </summary>
        public string Path
        {
            get
            {
                string path = @"....XmlReadWrite.xml";
                return path;
            }
        }

        /// <summary>
        /// 读取xml文件
        /// </summary>
        public void QueryElementByFile()
        {
            XElement xe = XElement.Load(Path);
            XElement xe1 = xe.Element("Item");
            Console.Write(xe1.Value.Trim());
            Console.ReadKey();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ 读取xml文件
            QueryXml xml = new QueryXml();
            xml.QueryElementByFile();
            #endregion
        }
    }

    运行结果如下：

    上面的示例，我们利用XElement的静态方法Load读取指定路径下的xml文件，同时还获取了该xml文件的第一个item的值并输出。

    2.2在xml指定节点前后添加新节点

    /// <summary>
    /// QueryXml类
    /// </summary>
    public class QueryXml
    {
        /// <summary>
        /// 返回xml文件路径
        /// </summary>
        public string Path
        {
            get
            {
                string path = @"....XmlReadWrite.xml";
                return path;
            }
        }

        /// <summary>
        /// 在xml指定节点前后添加新节点
        /// </summary>
        public void AddElementBeforeAndAfter()
        {
            XElement xe = XElement.Load(Path);
            var item = (from t in xe.Elements("Item")
                        where t.Value.Equals("Item2")
                        select t).SingleOrDefault();
            if (item != null)
            {
                XElement bxe = new XElement("Item", "ItemB");
                XElement axe = new XElement("Item", "ItemA");
                item.AddBeforeSelf(bxe);
                item.AddAfterSelf(axe);
                xe.Save(Path);
            }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ 在xml指定节点前后添加新节点
            QueryXml xml = new QueryXml();
            xml.AddElementBeforeAndAfter();
            #endregion
        }
    }

    最终生成的xml如下所示：

<?xml version="1.0" encoding="utf-8"?>
<Root>
  <Item v1="1" v2="2">Item1</Item>
  <Item>ItemB</Item>
  <Item v1="1" v2="2">Item2</Item>
  <Item>ItemA</Item>
</Root>

    2.3添加属性到xml节点中

    我们已经可以动态的添加节点，但是创建的时候不仅仅可以创建节点，并且还能创建属性，下面我们可以通过SetAttributeValue去添加新的属性或者

修改现有属性。

    /// <summary>
    /// QueryXml类
    /// </summary>
    public class QueryXml
    {
        /// <summary>
        /// 返回xml文件路径
        /// </summary>
        public string Path
        {
            get
            {
                string path = @"....XmlReadWrite.xml";
                return path;
            }
        }

        /// <summary>
        /// 添加属性到xml节点中
        /// </summary>
        public void AddAttributeToElement()
        {
            XElement xe = XElement.Parse(@"<?xml version='1.0' encoding='utf-8'?><Root>
                <Item v1='1' v2='2'>Item1</Item><Item v1='1' v2='2'>Item2</Item></Root>");
            var item = (from t in xe.Elements("Item")
                        where t.Value.Equals("Item2")
                        select t).SingleOrDefault();
            item.SetAttributeValue("v3", "3");
            xe.Save(Path);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ 添加属性到xml节点中
            QueryXml xml = new QueryXml();
            xml.AddAttributeToElement();
            #endregion
        }
    }

    最终生成的xml如下所示：

<?xml version="1.0" encoding="utf-8"?>
<Root>
  <Item v1="1" v2="2">Item1</Item>
  <Item v1="1" v2="2" v3="3">Item2</Item>
</Root>

    2.4添加注释到xml指定节点前后

    这里的语法基本跟【在xml指定节点前后添加新节点】是相似的，只是读取xml的方式不同。

    /// <summary>
    /// QueryXml类
    /// </summary>
    public class QueryXml
    {
        /// <summary>
        /// 返回xml文件路径
        /// </summary>
        public string Path
        {
            get
            {
                string path = @"....XmlReadWrite.xml";
                return path;
            }
        }

        /// <summary>
        /// 添加注释到xml指定节点前后
        /// </summary>
        public void AddCommentBeforeAndAfter()
        {
            TextReader tr = new StringReader(@"<?xml version='1.0' encoding='utf-8'?><Root>
                <Item v1='1' v2='2'>Item1</Item><Item v1='1' v2='2' v3='3'>Item2</Item></Root>");
            XElement xe = XElement.Load(tr);
            var item = (from t in xe.Elements("Item")
                        where t.Value.Equals("Item1")
                        select t).FirstOrDefault();
            if (item != null)
            {
                XComment bcom = new XComment("前面的注释");
                XComment acom = new XComment("后面的注释");
                item.AddBeforeSelf(bcom);
                item.AddAfterSelf(acom);
            }
            tr.Close();
            xe.Save(Path);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ 添加注释到xml指定节点前后
            QueryXml xml = new QueryXml();
            xml.AddCommentBeforeAndAfter();
            #endregion
        }
    }

    最终生成的xml如下所示：

<?xml version="1.0" encoding="utf-8"?>
<Root>
  <!--前面的注释-->
  <Item v1="1" v2="2">Item1</Item>
  <!--后面的注释-->
  <Item v1="1" v2="2" v3="3">Item2</Item>
</Root>

    2.5替换xml指定节点

    修改节点的值通过SetValue即可做到，但是有时涉及到子节点，而我们想一次性全部替换掉，那么我们就需要使用ReplaceWith。

    /// <summary>
    /// QueryXml类
    /// </summary>
    public class QueryXml
    {
        /// <summary>
        /// 返回xml文件路径
        /// </summary>
        public string Path
        {
            get
            {
                string path = @"....XmlReadWrite.xml";
                return path;
            }
        }

        /// <summary>
        /// 替换xml指定节点
        /// </summary>
        public void ReplaceElement()
        {
            XElement xe = XElement.Load(Path);
            var item = (from t in xe.Elements("Item")
                        where t.Value.Equals("Item2")
                        select t).FirstOrDefault();
            if (item != null)
            {
                item.ReplaceWith(new XElement("Item", "Item3"));
            }
            xe.Save(Path);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ 替换xml指定节点
            QueryXml xml = new QueryXml();
            xml.ReplaceElement();
            #endregion
        }
    }

    最终生成的xml如下所示：

<?xml version="1.0" encoding="utf-8"?>
<Root>
  <!--前面的注释-->
  <Item v1="1" v2="2">Item1</Item>
  <!--后面的注释-->
  <Item>Item3</Item>
</Root>

    2.6删除xml指定属性

    前面我们介绍了创建、修改和添加属性，但是还没有介绍如何删除指定的属性，下面我们就通过一个简单的实例来演示。

    /// <summary>
    /// QueryXml类
    /// </summary>
    public class QueryXml
    {
        /// <summary>
        /// 返回xml文件路径
        /// </summary>
        public string Path
        {
            get
            {
                string path = @"....XmlReadWrite.xml";
                return path;
            }
        }

        /// <summary>
        /// 删除xml指定属性
        /// </summary>
        public void RemoveAttribute()
        {
            XElement xe = XElement.Load(Path);
            var item = (from t in xe.Elements("Item")
                        where t.Value.Equals("Item1")
                        select t).FirstOrDefault().Attribute("v2");
            if (item != null)
            {
                item.Remove();
            }
            xe.Save(Path);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ 删除xml指定属性
            QueryXml xml = new QueryXml();
            xml.RemoveAttribute();
            #endregion
        }
    }

    最终生成的xml如下所示：

<?xml version="1.0" encoding="utf-8"?>
<Root>
  <!--前面的注释-->
  <Item v1="1">Item1</Item>
  <!--后面的注释-->
  <Item>Item3</Item>
</Root>

    2.7删除xml指定节点

    既然上面已经可以删除属性，自然也少不了删除属性。

    /// <summary>
    /// QueryXml类
    /// </summary>
    public class QueryXml
    {
        /// <summary>
        /// 返回xml文件路径
        /// </summary>
        public string Path
        {
            get
            {
                string path = @"....XmlReadWrite.xml";
                return path;
            }
        }

        /// <summary>
        /// 删除xml指定节点
        /// </summary>
        public void RemoveElement()
        {
            XElement xe = XElement.Load(Path);
            var item = (from t in xe.Elements("Item")
                        where t.Value.Equals("Item3")
                        select t).FirstOrDefault();
            if (item != null)
            {
                item.Remove();
            }
            xe.Save(Path);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ 删除xml指定节点
            QueryXml xml = new QueryXml();
            xml.RemoveElement();
            #endregion
        }
    }

    最终生成的xml如下所示：

<?xml version="1.0" encoding="utf-8"?>
<Root>
  <!--前面的注释-->
  <Item v1="1">Item1</Item>
  <!--后面的注释-->
</Root>

    三、按节点关系查询

    上面的查询都是通过相关的条件进行查询，但是我们有时仅仅只需要通过之间的关系即可，这样反而可以避免很多的代码，当然稍加探索可以发现其

实XElement都提供给我们了。

    创建一个Structure.xml文件：

<?xml version="1.0" encoding="utf-8" ?>
<Root>
  <Item>
    <SubItem1>
      1
    </SubItem1>
    <SubItem>
      <Child>
        sss
      </Child>
    </SubItem>
    <SubItem2>
      2
    </SubItem2>
  </Item>
</Root>

    3.1显示xml指定节点的所有父节点

    通过上面的xml文件，我们清晰的看出xml是具有结构性的，彼此之间都存在关系，而现在我们需要显示某个节点的父级节点的名称。

    /// <summary>
    /// StructureXml类
    /// </summary>
    public class StructureXml
    {
        public string Path
        {
            get
            {
                string path = string.Format(@"....Structure.xml");
                return path;
            }
        }

        /// <summary>
        /// 显示xml指定节点的所有父节点
        /// </summary>
        public void ShowAllParentElement()
        {
            XElement xe = XElement.Load(Path);
            var item = (from t in xe.Descendants("Child")
                        select t).FirstOrDefault();
            if (item != null)
            {
                Console.WriteLine("----------------------------");
                Console.WriteLine($"{item.Name}的向上父节点有：");
                foreach (var upper in item.Ancestors())
                {
                    Console.WriteLine(upper.Name);
                }
                Console.WriteLine("----------------------------");
                Console.WriteLine($"{item.Name}及向上父节点有：");
                foreach (var selfAndUpper in item.AncestorsAndSelf())
                {
                    Console.WriteLine(selfAndUpper.Name);
                }
                Console.Read();
            }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ 显示xml指定节点的所有父节点
            StructureXml xml = new StructureXml();
            xml.ShowAllParentElement();
            #endregion
        }
    }

    运行结果如下：

    3.2显示xml指定节点的所有子节点

    我们不仅仅可以输出一个节点的所有父级节点，同样也可以输出一个节点的所有子节点。

    /// <summary>
    /// StructureXml类
    /// </summary>
    public class StructureXml
    {
        public string Path
        {
            get
            {
                string path = string.Format(@"....Structure.xml");
                return path;
            }
        }

        /// <summary>
        /// 显示xml指定节点的所有子节点
        /// </summary>
        public void ShowAllChildElement()
        {
            XElement xe = XElement.Load(Path);
            Console.WriteLine("----------------------------");
            foreach (var sub in xe.Descendants())
            {
                Console.WriteLine(sub.Name);
            }
            Console.WriteLine("----------------------------");
            foreach (var sub in xe.DescendantsAndSelf())
            {
                Console.WriteLine(sub.Name);
            }
            Console.ReadKey();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ 显示xml指定节点的所有子节点
            StructureXml xml = new StructureXml();
            xml.ShowAllChildElement();
            #endregion
        }
    }

    运行结果如下：

    3.3显示xml同级节点之前的节点

    既然有了父子关系，当然也少不了同级关系，首先我们先显示同级节点之前的节点。

    /// <summary>
    /// StructureXml类
    /// </summary>
    public class StructureXml
    {
        public string Path
        {
            get
            {
                string path = string.Format(@"....Structure.xml");
                return path;
            }
        }

        /// <summary>
        /// 显示xml同级节点之前的节点
        /// </summary>
        public void ShowPrevElement()
        {
            XElement xe = XElement.Load(Path);
            var item = (from t in xe.Descendants("SubItem2")
                        select t).FirstOrDefault();
            if (item != null)
            {
                Console.WriteLine($"与{item.Name}同级的前节点有：");
                foreach (var sub in item.ElementsBeforeSelf())
                {
                    Console.WriteLine(sub.Name);
                }
            }
            Console.Read();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ 显示xml同级节点之前的节点
            StructureXml xml = new StructureXml();
            xml.ShowPrevElement();
            #endregion
        }
    }

    运行结果如下：

    3.4显示xml同级节点之后的节点

    /// <summary>
    /// StructureXml类
    /// </summary>
    public class StructureXml
    {
        public string Path
        {
            get
            {
                string path = string.Format(@"....Structure.xml");
                return path;
            }
        }

        /// <summary>
        /// 显示xml同级节点之后的节点
        /// </summary>
        public void ShowNextElement()
        {
            XElement xe = XElement.Load(Path);
            var item = (from t in xe.Descendants("SubItem1")
                        select t).FirstOrDefault();
            if (item != null)
            {
                Console.WriteLine($"与{item.Name}同级的后节点有：");
                foreach (var sub in item.ElementsAfterSelf())
                {
                    Console.WriteLine(sub.Name);
                }
            }
            Console.Read();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ 显示xml同级节点之后的节点
            StructureXml xml = new StructureXml();
            xml.ShowNextElement();
            #endregion
        }
    }

    运行结果如下：

    四、监听xml事件

    你可能会疑惑xml为什么还要监听？其实这样是有意义的，比如你要根据某个节点的值作为依赖，那么你就要监听这个节点，如果这个节点发生改变

的时候，你才可以及时的作出反应。但是xml的事件监听有一个特点，跟浏览器中的DOM事件类似，监听父节点同样也可以监听的到它的子节点的事件。

    下面我们通过一个简单的示例来说明：

    /// <summary>
    /// EventXml类
    /// </summary>
    public static class EventXml
    {
        public static void BindChangeing()
        {
            XElement xe = new XElement("Root");
            xe.Changing += XElement_Changing;
            xe.Changed += XElement_Changed;
            //添加元素
            xe.Add(new XElement("Item", "1"));
            var item = xe.Element("Item");
            //替换元素
            item.ReplaceWith(new XElement("Item", "2"));
            //删除元素
            item = xe.Element("Item");
            item.Remove();
            //读取结果
            Console.Read();
        }

        static void XElement_Changing(object sender, XObjectChangeEventArgs e)
        {
            XElement xe = sender as XElement;
            Console.WriteLine($"{xe.Name}正在进行{e.ObjectChange}操作中，sender={sender.ToString()}。");
        }

        static void XElement_Changed(object sender, XObjectChangeEventArgs e)
        {
            XElement xe = sender as XElement;
            Console.WriteLine($"{xe.Name}已完成{e.ObjectChange}操作，sender={sender.ToString()}。
");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ 监听xml事件
            EventXml.BindChangeing();
            #endregion
        }
    }

    运行结果如下：

    五、处理xml流

    在实际的商业化的开发中，xml不可能仅仅保存这么点数据，有可能保存着非常多的数据。假如我们还是按照以往的方式，就会将xml全部读取进内

存，这样会占用非常多的内存从而影响系统的性能。针对这种情况我们需要使用流的方式去处理xml，因为流会按照我们的顺序读取部分xml进内存，

并不会将所有xml都读取到内存中。

    创建一个Stream.xml文件：

<?xml version="1.0" encoding="utf-8" ?>
<Root>
  <SubItem>1</SubItem>
  <SubItem>1</SubItem>
  <SubItem>1</SubItem>
  <Item>A</Item>
  <SubItem>1</SubItem>
  <Item>B</Item>
</Root>

    这里我们通过XmlReader的Create静态方法打开xml文件，并通过Read一个节点的进行读取，并判断该节点的类型。

    /// <summary>
    /// ReadXmlStream类
    /// </summary>
    public static class ReadXmlStream
    {
        public static string Path
        {
            get
            {
                string path = @"....Stream.xml";
                return path;
            }
        }

        /// <summary>
        /// 流式处理XML
        /// </summary>
        public static void ReadXml()
        {
            XmlReader reader = XmlReader.Create(Path);
            while (reader.Read())
            {
                if (reader.NodeType == XmlNodeType.Element && reader.Name.Equals("Item"))
                {
                    XElement xe = XNode.ReadFrom(reader) as XElement;
                    Console.WriteLine(xe.Value.Trim());
                }
            }
            Console.Read();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            #region LINQ 处理xml流
            ReadXmlStream.ReadXml();
            #endregion
        }
    }

    运行结果如下：