C# LINQ學習筆記五：LINQ to XML

    本筆記摘抄自：https://www.cnblogs.com/yaozhenfa/p/CSharp_Linq_For_Xml.html，記錄一下學習過程以備後續查用。

    1、生成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
        }
    }

View Code

    最終生成的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
        }
    }

View Code

    最終生成的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
        }
    }

View Code

    最終生成的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
        }
    }

View Code

    最終生成的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
        }
    }

View Code

    最終生成的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屬性，而且值就是咱們賦給它的命名空間。

    2、查詢並修改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
        }
    }

View Code

    運行結果以下：

    上面的示例，咱們利用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
        }
    }

View Code

    最終生成的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
        }
    }

View Code

    最終生成的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
        }
    }

View Code

    最終生成的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
        }
    }

View Code

    最終生成的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
        }
    }

View Code

    最終生成的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
        }
    }

View Code

    最終生成的xml以下所示：

<?xml version="1.0" encoding="utf-8"?>
<Root>
  <!--前面的註釋-->
  <Item v1="1">Item1</Item>
  <!--後面的註釋-->
</Root>

    3、按節點關係查詢

    上面的查詢都是經過相關的條件進行查詢，可是咱們有時僅僅只須要經過之間的關係便可，這樣反而能夠避免不少的代碼，固然稍加探索能夠發現其

實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
        }
    }

View Code

    運行結果以下：

    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
        }
    }

View Code

    運行結果以下：

    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
        }
    }

View Code

    運行結果以下：

    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
        }
    }

View Code

    運行結果以下：

    4、監聽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()}。\n");
        }
    }

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

View Code

    運行結果以下：

    5、處理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
        }
    }

View Code

    運行結果以下：