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 属性可以做到这一点。

实例代码

显示行号复制代码？

```
/////检索元素的值
```

XElement e = new XElement("StringElement", "abcd");

```
Console.WriteLine(e);
```

Console.WriteLine("Value of e:" + (string)e);

Console.WriteLine("Value of e by Value:" + e.Value);

.src_container{background-color:#e7e5dc; width:99%; overflow:hidden; margin:12px 0 12px 0 !important; padding:0px 3px 3px 0px}
.src_container .titlebar{ background-color:#d4dfff; border:1px solid #4f81bd; border-bottom:0; padding:3px 24px; margin:0; width:auto; line-height:120%; overflow:hidden; text-align:left; font-size:12px}
.src_container .toolbar{ display:inline; font-weight:normal; font-size:100%; float:right; cursor:hand; color:#00f; text-align:left; overflow:hidden}
.toolbar span.button{ display:inline; font-weight:normal; font-size:100%; cursor:hand; color:#00f; text-align:left; overflow:hidden; cursor:pointer;}
.src_container div.clientarea{ background-color:white; border:1px solid #4f81bd; margin:0; width:auto !important; width:100%; height:auto; overflow:auto; text-align:left; font-size:12px; font-family: "Courier New","Consolas","Fixedsys",courier,monospace,serif}
.src_container ol.mainarea{ padding:0 0 0 52px; margin:0; background-color:#f7f7ff !important}
.number_show{ padding-left:52px !important; list-style:decimal outside !important}
.number_show li{ list-style:decimal outside !important; border-left:1px dotted #4f81bd}
.number_hide{ padding-left:0px !important; list-style-type:none !important}
.number_hide li{ list-style-type:none !important; border-left:0px}
ol.mainarea li{ display:list-item !important; font-size:12px !important; margin:0 !important; line-height:18px !important; padding:0 0 0 0px !important; background-color:#f7f7ff !important; color:#4f81bd}
ol.mainarea li pre{color:black; line-height:18px; padding:0 0 0 12px !important; margin:0em; background-color:#fff !important}
.linewrap ol.mainarea li pre{white-space:pre-wrap; white-space:-moz-pre-wrapwhite-space:-pre-wrap; white-space:-o-pre-wrap; word-wrap:break-word}
ol.mainarea li pre.alt{ background-color:#f7f7ff !important}

显示行号复制代码？

```
//检索元素集合
```

XElement po = XElement.Load("PurchaseOrder.xml");

IEnumerable<XElement> childElements = from el in po.Elements()

                                      select el;

```
foreach (XElement el in childElements)
```

    Console.WriteLine("Name: " + el.Name);

显示行号复制代码？

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

XElement po = XElement.Load("PurchaseOrder.xml");

IEnumerable<XElement> items = from el in po.Descendants("ProductName")

                              select el;

```
foreach (XElement proName in items)
```

    Console.Write("PrdName" + ":" + (string)proName);

显示行号复制代码？

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

XNamespace aw = "http://www.adventure-works.com";

XElement po = XElement.Load("PurchaseOrderInNamespace.xml");

IEnumerable<XElement> items = from el in po.Descendants(aw + "ProductName")

                              select el;

```
foreach (XElement prdName in items)
```

    Console.WriteLine(prdName.Name + ":" + (string)prdName);

显示行号复制代码？

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

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

IEnumerable<XElement> configParameters =root.Elements("Customer").Elements("Config").

                                        Elements("ConfigParameter");

foreach (XElement cp in configParameters)

```
    Console.WriteLine(cp.Value);
```

显示行号复制代码？

```
////检索单个子元素
```

XElement po = XElement.Load("PurchaseOrder.xml");

XElement e = po.Element("DeliveryNotes");

```
Console.WriteLine(e);
```

显示行号复制代码？

```
////检索属性type的值
```
```
XElement val = new XElement("Value",
```

                                    new XAttribute("ID", "1243"),

                                    new XAttribute("Type", "int"),

                                    new XAttribute("ConvertableTo", "double"),

```
                            "100");
```

IEnumerable<XAttribute> xa = from att in val.Attributes()

                             select att;

```
foreach (XAttribute a in xa)
```
```
    if (a.Name.ToString() == "Type")
```
```
        Console.WriteLine(a.Value);
```

显示行号复制代码？

XElement cust = new XElement("PhoneNumbers",

                             new XElement("Phone",

                             new XAttribute("type", "home"),

```
                     "555-555-5555"),
```
```
                 new XElement("Phone",
```

                             new XAttribute("type", "work"),

```
                     "555-555-6666")
```
```
             );
```

IEnumerable<XElement> elList = from el in cust.Descendants("Phone")

                               select el;

```
foreach (XElement el in elList)
```

    Console.WriteLine((string)el.Attribute("type"));

显示行号复制代码？

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

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

IEnumerable<XElement> address = from el in root.Elements("Address")

                                where (string)el.Attribute("Type") == "Billing"

                                select el;

```
foreach (XElement el in address)
```
```
    Console.WriteLine(el);
```

显示行号复制代码？

////查找具有特定子元素的元素

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

IEnumerable<XElement> tests = from el in root.Elements("Test")

                              where (string)el.Element("CommandLine") == "Examp2.EXE"

                              select el;

```
foreach (XElement el in tests)
```

    Console.WriteLine((string)el.Attribute("TestId"));

显示行号复制代码？

```
////编写使用复杂筛选的查询
```

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

IEnumerable<XElement> purchaseOrders = from el in root.Elements("PurchaseOrder")

                                       where

                                           (from add in el.Elements("Address")

                                            where

                                                (string)add.Attribute("Type") == "Shipping" &&

                                                (string)add.Element("State") == "NY"

                                            select add)

                                           .Any()

                                       select el;

foreach (XElement el in purchaseOrders)

    Console.WriteLine((string)el.Attribute("PurchaseOrderNumber"));

显示行号复制代码？

```
//筛选可选元素
```

XElement root = XElement.Parse(@"<Root>

```
 <Child1>
```

                <Text>Child One Text</Text>

```
 <Type Value=""Yes""/>
```
```
 </Child1>
```
```
 <Child2>
```

                <Text>Child Two Text</Text>

```
 <Type Value=""Yes""/>
```
```
 </Child2>
```
```
 <Child3>
```

                <Text>Child Three Text</Text>

```
 <Type Value=""No""/>
```
```
 </Child3>
```
```
 <Child4>
```

                <Text>Child Four Text</Text>

```
 <Type Value=""Yes""/>
```
```
 </Child4>
```
```
 <Child5>
```

                <Text>Child Five Text</Text>

```
 </Child5>
```
```
 </Root>");
```

var cList = from typeElement in root.Elements().Elements("Type")

            where (string)typeElement.Attribute("Value") == "Yes"

            select (string)typeElement.Parent.Element("Text");

```
foreach (string str in cList)
```
```
    Console.WriteLine(str);
```

显示行号复制代码？

```
//对元素进行排序
```

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

IEnumerable<decimal> prices = from el in root.Elements("Data")

                              let price = (decimal)el.Element("Price")

                              orderby price

                              select price;

```
foreach (decimal el in prices)
```
```
    Console.WriteLine(el);
```

显示行号复制代码？

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

XElement co = XElement.Load("CustomersOrders.xml");

var sortedElements = from c in co.Element("Orders").Elements("Order")

                     orderby (string)c.Element("ShipInfo").Element("ShipPostalCode"),

                             (DateTime)c.Element("OrderDate")

```
                     select new
```
```
                     {
```

                         CustomerID = (string)c.Element("CustomerID"),

                         EmployeeID = (string)c.Element("EmployeeID"),

                         ShipPostalCode = (string)c.Element("ShipInfo").Element("ShipPostalCode"),

                         OrderDate = (DateTime)c.Element("OrderDate")

```
                     };
```
```
foreach (var r in sortedElements)
```

    Console.WriteLine("CustomerID:{0} EmployeeID:{1} ShipPostalCode:{2} OrderDate:{3:d}",

        r.CustomerID, r.EmployeeID, r.ShipPostalCode, r.OrderDate);

显示行号复制代码？

```
////计算中间值
```

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

IEnumerable<decimal> extensions = from el in root.Elements("Data")

                                  let extension = (decimal)el.Element("Quantity") * (decimal)el.Element("Price")

                                  where extension >= 25

                                  orderby extension

                                  select extension;

```
foreach (decimal ex in extensions)
```
```
    Console.WriteLine(ex);
```

显示行号复制代码？

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

```
XElement doc = XElement.Parse(@"<Root>
```
```
 
```
```
 <ul>abc</ul>
```
```
 <Child>
```
```
 
```
```
 <notul/>
```
```
 
```
```
 <ul>def</ul>
```
```
 
```
```
 </Child>
```
```
 <Child>
```
```
 
```
```
 <notul/>
```
```
 
```
```
 <ul>abc</ul>
```
```
 
```
```
 </Child>
```
```
 </Root>");
```

IEnumerable<XElement> items = from e in doc.Descendants("p")

                              let z = e.ElementsAfterSelf().FirstOrDefault()

                              where z != null && z.Name.LocalName == "ul"

                              select e;

```
foreach (XElement e in items)
```

    Console.WriteLine("id = {0}", (string)e.Attribute("id"));

显示行号复制代码？

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

Dictionary<string, string> dict = new Dictionary<string, string>();

```
dict.Add("Child1", "Value1");
```
```
dict.Add("Child2", "Value2");
```
```
dict.Add("Child3", "Value3");
```
```
dict.Add("Child4", "Value4");
```
```
XElement root = new XElement("Root",
```
```
      from keyValue in dict
```

      select new XElement(keyValue.Key, keyValue.Value)

```
);
```

显示行号复制代码？

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

Dictionary<string, string> dict = new Dictionary<string, string>();

foreach (XElement el in root.Elements())

    dict.Add(el.Name.LocalName, el.Value);

```
foreach (string str in dict.Keys)
```

    Console.WriteLine("{0}:{1}", str, dict[str]);

```
Console.WriteLine(root);
```

转自：http://www.cnblogs.com/lynstone/archive/2009/09/26/1574162.html

时间： 2024-10-05 18:31:12

LINQ to XML 实战

实例代码

LINQ to XML 实战的相关文章

24.C#LINQ TO XML(十二章12.3)

LINQ to XML 编程基础

XML读写利器XElement（Linq to xml）

Linq之Linq to XML

LINQ to XML（1）

Linq To XML 简单操作

Linq学习随笔二------LINQ to XML

LINQ to XML编程之编程基础

Silverlight 使用IsolatedStorage新建XML文件，并且用LINQ查询XML