2. 程式人生 > 其它 >C# LINQ學習筆記五：LINQ to XML

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

阿新 • • 發佈：2020-12-13

技術標籤：C# Linq

本筆記摘抄自：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()}。\n");
        }
    }

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

執行結果如下：

在這裡插入圖片描述

相關推薦

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

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

C#可擴充套件程式設計之MEF學習筆記(五)：MEF高階進階

好久沒有寫部落格了，今天抽空繼續寫MEF系列的文章。有園友提出這種系列的文章要做個目錄，看起來方便，所以就抽空做了一個，放到每篇文章的最後。

《javascript設計模式》學習筆記五：Javascript面向物件程式設計工廠模式例項分析

本文例項講述了Javascript面向物件程式設計工廠模式。分享給大家供大家參考，具體如下：

C++ STL學習筆記之：佇列（queue）、雙端佇列（deque）與棧（stack）

queue（佇列） 定義一個名為 que 的儲存 int 型別元素的佇列： queue<int> que; 入隊操作：

迪文螢幕學習筆記五：用彈出選單模擬下拉選單

最近在用迪文螢幕開發一個專案，其中用到下拉選單功能，檢視迪文開發 手冊觸控控制元件章節，並沒有下拉選單按鈕，但是有下面這句話：

Oracle學習筆記五：資料庫例項管理

一、資料庫的啟動與關閉 1.1、資料庫啟動過程 1.2、資料庫啟動命令 STARTUP 1.3、更改資料庫狀態

Java IO學習筆記五：BIO到NIO

作者：Grey 原文地址: Java IO學習筆記五：BIO到NIO 準備環境 準備一個CentOS7的Linux例項：

學習筆記五：必知必會的HTTP協議

HTTP協議： 超文字傳輸協議（HTTP，HyperText Transfer Protocol）是網際網路上應用最為廣泛的一種網路協議。所有的WWW檔案都必須遵守這個標準。設計HTTP最初的目的是為了提供一種釋出和接收HTML頁面的方法。1960年

C#佇列學習筆記：RabbitMQ延遲佇列

一、引言 日常生活中，很多的APP都有延遲佇列的影子。比如在手機淘寶上，經常遇到APP派發的限時消費紅包，一般有幾個小時或24小時不等。假如在紅包倒計時的過程中，沒有消費掉紅包的話，紅包會自動失效。假如上述行為

C#佇列學習筆記：RabbitMQ優先順序佇列

原文:C#佇列學習筆記：RabbitMQ優先順序佇列 一、引言 在具體業務中可能會遇到一些要提前處理的訊息，比如普通客戶的訊息按先進先出的順序處理，Vip客戶的訊息要提前處理。在RabbitMQ中，訊息優先順序的實現方式是

C#佇列學習筆記：RabbitMQ實現客戶端相互通訊

原文:C#佇列學習筆記：RabbitMQ實現客戶端相互通訊 一、引言 fanout型別的Exchange，路由規則非常簡單：它會把所有傳送到該Exchange的訊息，路由到所有與它繫結的Queue中。假設有一個聊天室，各個客戶端都訂閱在同

C# ORM學習筆記：使用特性+反射實現簡單ORM

原文:C# ORM學習筆記：使用特性+反射實現簡單ORM 一、原理與環境 在生成資料表的實體類時，利用自定義特性，給它打上表及欄位的特性，然後使用反射原理，將自定義特性拼接成增、刪、改、查對應的SQL，即可完成一個

（C++11/14/17學習筆記）：互斥量概念、用法、死鎖演示及解決詳解

技術標籤：C++11/14/17 目錄 互斥量概念、用法、死鎖演示及解決詳解 互斥量(mutex)的基本概念

（C++11/14/17學習筆記）：執行緒傳參詳解，detach()陷阱，成員函式做執行緒函式

技術標籤：C++11/14/17 目錄 執行緒傳參詳解，detach()陷阱，成員函式做執行緒函式

（C++11/14/17學習筆記）：單例設計模式共享資料分析，call_once()函式

技術標籤：C++11/14/17 目錄 單例設計模式共享資料分析、解決，call_once 設計模式大概談

（C++11/14/17學習筆記）：std::atomic續、std::async與std::thread對比

技術標籤：C++11/14/17 目錄 std::atomic續、std::async與std::thread對比 原子操作std::atomic續談

C# 好程式碼學習筆記(1)：檔案操作、讀取檔案、Debug/Trace 類、Conditional條件編譯、CLS

目錄1，檔案操作2，讀取檔案3，Debug 、Trace類4，條件編譯5，MethodImpl 特性5，CLSCompliantAttribute6，必要時自定義類型別名

OpenNetworkLinux：i2c-gpio.c原始碼學習筆記

技術標籤：Linux驅動開發 OpenNetworkLinux：i2c-gpio.c原始碼學習筆記 i2c-gpio驅動init和exit

C#學習筆記(2)：方法

以《C#6.0本質論（Essential C# 6.0）》為基本，參考《深入解析C#（C# in Depth, 4th Edition）》、《C#圖解教程（Illustrated C# 7, 5th Edition）》。圓括號內是本質論書中位置、方括號是個人補充

C#學習筆記(1)：資料型別

以《C#6.0本質論（Essential C# 6.0）》為基本，參考《深入解析C#（C# in Depth, 4th Edition）》、《C#圖解教程（Illustrated C# 7, 5th Edition）》。圓括號內是本質論書中位置、方括號是個人補充