主頁 > .NET開發 > C# LINQ學習筆記五：LINQ to XML

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

2020-09-20 06:08:50 .NET開發

    本筆記摘抄自：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
        }
    }
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屬性，并且值就是我們賦給它的命名空間，

    二、查詢并修改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>

    三、按節點關系查詢

    上面的查詢都是通過相關的條件進行查詢，但是我們有時僅僅只需要通過之間的關系即可，這樣反而可以避免很多的代碼，當然稍加探索可以發現其

實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

    運行結果如下：

    四、監聽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

    運行結果如下：

    五、處理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

    運行結果如下：

轉載請註明出處，本文鏈接：https://www.uj5u.com/net/86483.html

標籤：C#

上一篇：3、IOC--手寫Unity容器--鏈式依賴--第N層依賴注入

下一篇：C# 索引器的理解和使用

標籤雲
其他(157675) Python(38076) JavaScript(25376) Java(17977) C(15215) 區塊鏈(8255) C＃(7972) AI(7469) 爪哇(7425) MySQL(7132) html(6777) 基礎類(6313) sql(6102) 熊猫(6058) PHP(5869) 数组(5741) R(5409) Linux(5327) 反应(5209) 腳本語言(PerlPython)(5129) 非技術區(4971) Android(4554) 数据框(4311) css(4259) 节点.js(4032) C語言(3288) json(3245) 列表(3129) 扑(3119) C++語言(3117) 安卓(2998) 打字稿(2995) VBA(2789) Java相關(2746) 疑難問題(2699) 细绳(2522) 單片機工控(2479) iOS(2429) ASP.NET(2402) MongoDB(2323) 麻木的(2285) 正则表达式(2254) 字典(2211) 循环(2198) 迅速(2185) 擅长(2169) 镖(2155) 功能(1967) .NET技术(1958) Web開發(1951) python-3.x(1918) HtmlCss(1915) 弹簧靴(1913) C++(1909) xml(1889) PostgreSQL(1872) .NETCore(1853) 谷歌表格(1846) Unity3D(1843) for循环(1842)

熱門瀏覽
  • WebAPI簡介

    Web體系結構： 有三個核心：資源(resource)，URL(統一資源識別符號)和表示 他們的關系是這樣的：一個資源由一個URL進行標識，HTTP客戶端使用URL定位資源，表示是從資源回傳資料，媒體型別是資源回傳的資料格式。 接下來我們說下HTTP. HTTP協議的系統是一種無狀態的方式，使用請求/ ......

    uj5u.com 2020-09-09 22:07:47 more
  • asp.net core 3.1 入口：Program.cs中的Main函式

    本文分析Program.cs 中Main()函式中代碼的運行順序分析asp.net core程式的啟動，重點不是剖析原始碼，而是理清程式開始時執行的順序。到呼叫了哪些實體，哪些法方。asp.net core 3.1 的程式入口在專案Program.cs檔案里，如下。ususing System; us ......

    uj5u.com 2020-09-09 22:07:49 more
  • asp.net網站作為websocket服務端的應用該如何寫

    最近被websocket的一個問題困擾了很久，有一個需求是在web網站中搭建websocket服務。客戶端通過網頁與服務器建立連接，然后服務器根據ip給客戶端網頁發送資訊。 其實，這個需求并不難，只是剛開始對websocket的內容不太了解。上網搜索了一下，有通過asp.net core 實作的、有 ......

    uj5u.com 2020-09-09 22:08:02 more
  • ASP.NET 開源匯入匯出庫Magicodes.IE Docker中使用

    Magicodes.IE在Docker中使用 更新歷史 2019.02.13 【Nuget】版本更新到2.0.2 【匯入】修復單列匯入的Bug，單元測驗“OneColumnImporter_Test”。問題見（https://github.com/dotnetcore/Magicodes.IE/is ......

    uj5u.com 2020-09-09 22:08:05 more
  • 在webform中使用ajax

    如果你用過Asp.net webform， 說明你也算是.NET 開發的老兵了。WEBform應該是2011 2013左右，當時還用visual studio 2005、 visual studio 2008。后來基本都用的是MVC。 如果是新開發的專案，估計沒人會用webform技術。但是有些舊版 ......

    uj5u.com 2020-09-09 22:08:50 more
  • iis添加asp.net網站，訪問提示：由于擴展配置問題而無法提供您請求的

    今天在iis服務器配置asp.net網站，遇到一個問題，記錄一下： 問題：由于擴展配置問題而無法提供您請求的頁面。如果該頁面是腳本，請添加處理程式。如果應下載檔案，請添加 MIME 映射。 WindowServer2012服務器，添加角色安裝完.netframework和iis之后，運行aspx頁面 ......

    uj5u.com 2020-09-09 22:10:00 more
  • WebAPI-處理架構

    帶著問題去思考，大家好！ 問題1：HTTP請求和回傳相應的HTTP回應資訊之間發生了什么？ 1：首先是最底層，托管層，位于WebAPI和底層HTTP堆疊之間 2：其次是 訊息處理程式管道層，這里比如日志和快取。OWIN的參考是將訊息處理程式管道的一些功能下移到堆疊下端的OWIN中間件了。 3：控制器處理 ......

    uj5u.com 2020-09-09 22:11:13 more
  • 微信門戶開發框架-使用指導說明書

    微信門戶應用管理系統，采用基于 MVC + Bootstrap + Ajax + Enterprise Library的技術路線，界面層采用Boostrap + Metronic組合的前端框架，資料訪問層支持Oracle、SQLServer、MySQL、PostgreSQL等資料庫。框架以MVC5，... ......

    uj5u.com 2020-09-09 22:15:18 more
  • WebAPI-HTTP編程模型

    帶著問題去思考，大家好！它是什么？它包含什么？它能干什么？ 訊息 HTTP編程模型的核心就是訊息抽象，表示為：HttPRequestMessage,HttpResponseMessage.用于客戶端和服務端之間交換請求和回應訊息。 HttpMethod類包含了一組靜態屬性： private stat ......

    uj5u.com 2020-09-09 22:15:23 more
  • 部署WebApi隨筆

    一、跨域 NuGet參考Microsoft.AspNet.WebApi.Cors WebApiConfig.cs中配置： // Web API 配置和服務 config.EnableCors(new EnableCorsAttribute("*", "*", "*")); 二、清除默認回傳XML格式 ......

    uj5u.com 2020-09-09 22:15:48 more
最新发布
  • C#多執行緒學習(二) 如何操縱一個執行緒

    <a href="https://www.cnblogs.com/x-zhi/" target="_blank"><img width="48" height="48" class="pfs" src="https://pic.cnblogs.com/face/2943582/20220801082530.png" alt="" /></...

    uj5u.com 2023-04-19 09:17:20 more
  • C#多執行緒學習(二) 如何操縱一個執行緒

    C#多執行緒學習(二) 如何操縱一個執行緒 執行緒學習第一篇：C#多執行緒學習(一) 多執行緒的相關概念 下面我們就動手來創建一個執行緒，使用Thread類創建執行緒時，只需提供執行緒入口即可。（執行緒入口使程式知道該讓這個執行緒干什么事） 在C#中，執行緒入口是通過ThreadStart代理（delegate）來提供的 ......

    uj5u.com 2023-04-19 09:16:49 more
  • 記一次 .NET某醫療器械清洗系統 卡死分析

    <a href="https://www.cnblogs.com/huangxincheng/" target="_blank"><img width="48" height="48" class="pfs" src="https://pic.cnblogs.com/face/214741/20200614104537.png" alt="" /&g...

    uj5u.com 2023-04-18 08:39:04 more
  • 記一次 .NET某醫療器械清洗系統 卡死分析

    一：背景 1. 講故事 前段時間協助訓練營里的一位朋友分析了一個程式卡死的問題，回過頭來看這個案例比較經典，這篇稍微整理一下供后來者少踩坑吧。 二：WinDbg 分析 1. 為什么會卡死 因為是表單程式，理所當然就是看主執行緒此時正在做什么? 可以用 ~0s ; k 看一下便知。 0:000> k # ......

    uj5u.com 2023-04-18 08:33:10 more
  • SignalR, No Connection with that ID，IIS

    <a href="https://www.cnblogs.com/smartstar/" target="_blank"><img width="48" height="48" class="pfs" src="https://pic.cnblogs.com/face/u36196.jpg" alt="" /></a>...

    uj5u.com 2023-03-30 17:21:52 more
  • 一次對pool的誤用導致的.net頻繁gc的診斷分析

    <a href="https://www.cnblogs.com/dotnet-diagnostic/" target="_blank"><img width="48" height="48" class="pfs" src="https://pic.cnblogs.com/face/3115652/20230225090434.png" alt=""...

    uj5u.com 2023-03-28 10:15:33 more
  • 一次對pool的誤用導致的.net頻繁gc的診斷分析

    <a href="https://www.cnblogs.com/dotnet-diagnostic/" target="_blank"><img width="48" height="48" class="pfs" src="https://pic.cnblogs.com/face/3115652/20230225090434.png" alt=""...

    uj5u.com 2023-03-28 10:13:31 more
  • C#遍歷指定檔案夾中所有檔案的3種方法

    <a href="https://www.cnblogs.com/xbhp/" target="_blank"><img width="48" height="48" class="pfs" src="https://pic.cnblogs.com/face/957602/20230310105611.png" alt="" /></a&...

    uj5u.com 2023-03-27 14:46:55 more
  • C#/VB.NET：如何將PDF轉為PDF/A

    <a href="https://www.cnblogs.com/Carina-baby/" target="_blank"><img width="48" height="48" class="pfs" src="https://pic.cnblogs.com/face/2859233/20220427162558.png" alt="" />...

    uj5u.com 2023-03-27 14:46:35 more
  • 武裝你的WEBAPI-OData聚合查詢

    <a href="https://www.cnblogs.com/podolski/" target="_blank"><img width="48" height="48" class="pfs" src="https://pic.cnblogs.com/face/616093/20140323000327.png" alt="" /><...

    uj5u.com 2023-03-27 14:46:16 more

Copyright © 2010-2020 有解無憂