LINQ to XML 实战

LINQ to XML 轴
定义：
创建XML树或将XML文档加载到XML树之后，可以进行查询，从而查找元素并检索它们的值。


两类轴方法：
-一些轴就是XELement和XDocument类中返回IEnumerable(T)集合的方法。
-另一些轴方法是Extensions类中的扩展方法。实现为扩展方法的轴对集合进行操作，然后返回集合。
XContainer是XElement的基类！


-常见的轴方法：
-XContainer.Elements()返回集合


-XContainer.Descendants()返回集合


-XContainer.Element()返回单个元素


-XElement.Attribute(XName)返回单个属性


-XElement.Attributes(XName)返回所有属性集合


下面是XElement类（或其基类）的方法汇总，可以对XElement调用这些方法以返回元素集合
-XNode.Ancestors  返回此元素的上级的XElement的IEnumerable(T)


-XContainer.Descendants   返回此元素的子代的XElement的IEnumerable(T)


-XContainer.Elements  返回此元素的子元素XElement的IEnumerable(T)


-XNode.ElementsAfterSelf  返回此元素之后的元素的XElement的IEnumerable(T)


-XNode.ElementsBeforeSelf  返回此元素之前的元素的XElement的IEnumerable(T)


-XElement.AncestorsAndSelf  返回此元素及其上级的XElement的IEnumerable(T)


-XElementDescendantsAndSelf  返回此元素及其子代的XElement的IEnumerable(T)


如何获取元素的值，有两种主要方法可以完成此操作
– 一种方法是将XElement 或XAttribute 强制转换为所需的类型。然后，显式转换运算符将元素或属性的内容转换为指定的类型，并将其分配给变量。


– 此外，还可以使用XElement.Value 属性或XAttribute.Value 属性，但是，对于C#，强制转换通常是更好的方法。在检索可能存在也可能不存在的元素（或属性）的值时，如果将元素或属性强制转换为可以为null 的类型，则代码会更易于编写无法通过强制转换设置元素的内容，而通过XElement.Value 属性可以做到这一点。

实例代码

////编写使用复杂筛选的查询   
  1.            XElement root = XElement.Load("PurchaseOrders.xml");  
  2.            IEnumerable<XElement> purchaseOrders =  
  3.                from el in root.Elements("PurchaseOrder")  
  4.                where  
  5.                    (from add in el.Elements("Address")  
  6.                     where  
  7.                         (string)add.Attribute("Type") == "Shipping" &&  
  8.                         (string)add.Element("State") == "NY"  
  9.                     select add)  
  10.                    .Any()  
  11.                select el;  
  12.            foreach (XElement el in purchaseOrders)  
  13.                Console.WriteLine((string)el.Attribute("PurchaseOrderNumber"));  

//            //筛选可选元素   

  1.            XElement root = XElement.Parse(@"<Root>  
  2.                          <Child1>  
  3.                            <Text>Child One Text</Text>  
  4.                            <Type Value=""Yes""/>  
  5.                          </Child1>  
  6.                          <Child2>  
  7.                            <Text>Child Two Text</Text>  
  8.                            <Type Value=""Yes""/>  
  9.                          </Child2>  
  10.                          <Child3>  
  11.                            <Text>Child Three Text</Text>  
  12.                            <Type Value=""No""/>  
  13.                          </Child3>  
  14.                          <Child4>  
  15.                            <Text>Child Four Text</Text>  
  16.                            <Type Value=""Yes""/>  
  17.                          </Child4>  
  18.                          <Child5>  
  19.                            <Text>Child Five Text</Text>  
  20.                          </Child5>  
  21.                        </Root>");  
  22.            var cList =  
  23.                from typeElement in root.Elements().Elements("Type")  
  24.                where (string)typeElement.Attribute("Value") == "Yes"  
  25.                select (string)typeElement.Parent.Element("Text");  
  26.            foreach (string str in cList)  
  27.                Console.WriteLine(str);  

//对元素进行排序   

  1.             XElement root = XElement.Load("Data.xml");  
  2.             IEnumerable<decimal> prices =  
  3.                 from el in root.Elements("Data")  
  4.                 let price = (decimal)el.Element("Price")  
  5.                 orderby price  
  6.                 select price;  
  7.             foreach (decimal el in prices)  
  8.                 Console.WriteLine(el);  

////对多个键上的元素进行排序   

  1.             XElement co = XElement.Load("CustomersOrders.xml");  
  2.             var sortedElements =  
  3.                 from c in co.Element("Orders").Elements("Order")  
  4.                 orderby (string)c.Element("ShipInfo").Element("ShipPostalCode"),  
  5.                         (DateTime)c.Element("OrderDate")  
  6.                 select new  
  7.                 {  
  8.                     CustomerID = (string)c.Element("CustomerID"),  
  9.                     EmployeeID = (string)c.Element("EmployeeID"),  
  10.                     ShipPostalCode = (string)c.Element("ShipInfo").Element("ShipPostalCode"),  
  11.                     OrderDate = (DateTime)c.Element("OrderDate")  
  12.                 };  
  13.             foreach (var r in sortedElements)  
  14.                 Console.WriteLine("CustomerID:{0} EmployeeID:{1} ShipPostalCode:{2} OrderDate:{3:d}",  
  15.                     r.CustomerID, r.EmployeeID, r.ShipPostalCode, r.OrderDate);  

////计算中间值   

  1.            XElement root = XElement.Load("Data.xml");  
  2.            IEnumerable<decimal> extensions =  
  3.                from el in root.Elements("Data")  
  4.                let extension = (decimal)el.Element("Quantity") * (decimal)el.Element("Price")  
  5.                where extension >= 25  
  6.                orderby extension  
  7.                select extension;  
  8.            foreach (decimal ex in extensions)  
  9.                Console.WriteLine(ex);  

//编写基于上下文查找元素的查询   

  1.             XElement doc = XElement.Parse(@"<Root>  
  2.                             <p id=""1""/>  
  3.                             <ul>abc</ul>  
  4.                             <Child>  
  5.                                 <p id=""2""/>  
  6.                                 <notul/>  
  7.                                 <p id=""3""/>  
  8.                                 <ul>def</ul>  
  9.                                 <p id=""4""/>  
  10.                             </Child>  
  11.                             <Child>  
  12.                                 <p id=""5""/>  
  13.                                 <notul/>  
  14.                                 <p id=""6""/>  
  15.                                 <ul>abc</ul>  
  16.                                 <p id=""7""/>  
  17.                             </Child>  
  18.                         </Root>");  
  19.   
  20.             IEnumerable<XElement> items =  
  21.                 from e in doc.Descendants("p")  
  22.                 let z = e.ElementsAfterSelf().FirstOrDefault()  
  23.                 where z != null && z.Name.LocalName == "ul"  
  24.                 select e;  
  25.   
  26.             foreach (XElement e in items)  
  27.                 Console.WriteLine("id = {0}", (string)e.Attribute("id"));  

////通过 LINQ to XML 使用字典   

  1.             Dictionary<string, string> dict = new Dictionary<string, string>();  
  2.             dict.Add("Child1", "Value1");  
  3.             dict.Add("Child2", "Value2");  
  4.             dict.Add("Child3", "Value3");  
  5.             dict.Add("Child4", "Value4");  
  6.             XElement root = new XElement("Root",  
  7.                 from keyValue in dict  
  8.                 select new XElement(keyValue.Key, keyValue.Value)  
  9.             );  

XElement root = XElement.Load("Data.xml");  

  1. Dictionary<string, string> dict = new Dictionary<string, string>();  
  2. foreach (XElement el in root.Elements())  
  3.     dict.Add(el.Name.LocalName, el.Value);  
  4. foreach (string str in dict.Keys)  
  5.     Console.WriteLine("{0}:{1}", str, dict[str]);  
  6. Console.WriteLine(root);  

/////检索元素的值   

  1. XElement e = new XElement("StringElement", "abcd");  
  2. Console.WriteLine(e);  
  3. Console.WriteLine("Value of e:" + (string)e);  
  4. Console.WriteLine("Value of e by Value:" + e.Value);  

//检索元素集合   

  1. XElement po = XElement.Load("PurchaseOrder.xml");  
  2. IEnumerable<XElement> childElements = from el in po.Elements()  
  3.                                       select el;  
  4. foreach (XElement el in childElements)  
  5.     Console.WriteLine("Name: " + el.Name);  

////根据元素的名称进行筛选   

  1. XElement po = XElement.Load("PurchaseOrder.xml");  
  2. IEnumerable<XElement> items = from el in po.Descendants("ProductName")  
  3.                               select el;  
  4. foreach (XElement proName in items)  
  5.     Console.Write("PrdName" + ":" + (string)proName);  

////根据元素的名称进行筛选（有命名空间）   

  1. XNamespace aw = "http://www.adventure-works.com";  
  2. XElement po = XElement.Load("PurchaseOrderInNamespace.xml");  
  3. IEnumerable<XElement> items = from el in po.Descendants(aw + "ProductName")  
  4.                               select el;  
  5. foreach (XElement prdName in items)  
  6.     Console.WriteLine(prdName.Name + ":" + (string)prdName);  

////链接轴方法,有时，当可能存在或不存在间隔上级时，您希望在特定的元素深度，检索所有的元素   

  1. XElement root = XElement.Load("Irregular.xml");  
  2. IEnumerable<XElement> configParameters =root.Elements("Customer").Elements("Config").  
  3.                                         Elements("ConfigParameter");  
  4. foreach (XElement cp in configParameters)  
  5.     Console.WriteLine(cp.Value);  

////检索单个子元素  

  1. XElement po = XElement.Load("PurchaseOrder.xml");  
  2. XElement e = po.Element("DeliveryNotes");  
  3. Console.WriteLine(e);  

////检索属性type的值   

  1. XElement val = new XElement("Value",  
  2.                                     new XAttribute("ID", "1243"),  
  3.                                     new XAttribute("Type", "int"),  
  4.                                     new XAttribute("ConvertableTo", "double"),  
  5.                             "100");  
  6. IEnumerable<XAttribute> xa = from att in val.Attributes()  
  7.                              select att;  
  8. foreach (XAttribute a in xa)  
  9.     if (a.Name.ToString() == "Type")  
  10.         Console.WriteLine(a.Value);  

 

XElement cust = new XElement("PhoneNumbers",  

  1.                              new XElement("Phone",  
  2.                              new XAttribute("type", "home"),  
  3.                      "555-555-5555"),  
  4.                  new XElement("Phone",  
  5.                              new XAttribute("type", "work"),  
  6.                      "555-555-6666")  
  7.              );  
  8. IEnumerable<XElement> elList = from el in cust.Descendants("Phone")  
  9.                                select el;  
  10. foreach (XElement el in elList)  
  11.     Console.WriteLine((string)el.Attribute("type"));  

////查找具有特定属性的元素   

  1. XElement root = XElement.Load("PurchaseOrder.xml");  
  2. IEnumerable<XElement> address = from el in root.Elements("Address")  
  3.                                 where (string)el.Attribute("Type") == "Billing"  
  4.                                 select el;  
  5. foreach (XElement el in address)  
  6.     Console.WriteLine(el);  

////查找具有特定子元素的元素   
  1. XElement root = XElement.Load("TestConfig.xml");  
  2. IEnumerable<XElement> tests = from el in root.Elements("Test")  
  3.                               where (string)el.Element("CommandLine") == "Examp2.EXE"  
  4.                               select el;  
  5. foreach (XElement el in tests)  
  6.     Console.WriteLine((string)el.Attribute("TestId"));  
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/cpcpc/p/2167922.html