LINQ to XML Overview
Collapse the table of content
Expand the table of content

LINQ to XML Overview


XML has been widely adopted as a way to format data in many contexts. For example, you can find XML on the Web, in configuration files, in Microsoft Office Word files, and in databases.

LINQ to XML is an up-to-date, redesigned approach to programming with XML. It provides the in-memory document modification capabilities of the Document Object Model (DOM), and supports LINQ query expressions. Although these query expressions are syntactically different from XPath, they provide similar functionality.

LINQ to XML targets a variety of developers. For an average developer who just wants to get something done, LINQ to XML makes XML easier by providing a query experience that is similar to SQL. With just a bit of study, programmers can learn to write succinct and powerful queries in their programming language of choice.

Professional developers can use LINQ to XML to greatly increase their productivity. With LINQ to XML, they can write less code that is more expressive, more compact, and more powerful. They can use query expressions from multiple data domains at the same time.

LINQ to XML is a LINQ-enabled, in-memory XML programming interface that enables you to work with XML from within the .NET Framework programming languages.

LINQ to XML is like the Document Object Model (DOM) in that it brings the XML document into memory. You can query and modify the document, and after you modify it you can save it to a file or serialize it and send it over the Internet. However, LINQ to XML differs from DOM: It provides a new object model that is lighter weight and easier to work with, and that takes advantage of language improvements in Visual C# 2008.

The most important advantage of LINQ to XML is its integration with Language-Integrated Query (LINQ). This integration enables you to write queries on the in-memory XML document to retrieve collections of elements and attributes. The query capability of LINQ to XML is comparable in functionality (although not in syntax) to XPath and XQuery. The integration of LINQ in Visual C# 2008 provides stronger typing, compile-time checking, and improved debugger support.

Another advantage of LINQ to XML is the ability to use query results as parameters to XElement and XAttribute object constructors enables a powerful approach to creating XML trees. This approach, called functional construction, enables developers to easily transform XML trees from one shape to another.

For example, you might have a typical XML purchase order as described in Sample XML File: Typical Purchase Order (LINQ to XML). By using LINQ to XML, you could run the following query to obtain the part number attribute value for every item element in the purchase order:

IEnumerable<string> partNos =
    from item in purchaseOrder.Descendants("Item")
    select (string) item.Attribute("PartNumber");

In Visual Basic, the same query can be written as follows:

Dim partNos = _
    From item In purchaseOrder...<Item> _
    Select item.@PartNumber

As another example, you might want a list, sorted by part number, of the items with a value greater than $100. To obtain this information, you could run the following query:

IEnumerable<XElement> partNos =
    from item in purchaseOrder.Descendants("Item")
    where (int) item.Element("Quantity") *
        (decimal) item.Element("USPrice") > 100
    orderby (string)item.Element("PartNumber")
    select item;

In Visual Basic, the same query can be written as follows:

Dim partNos = _
    From item In purchaseOrder...<Item> _
    Where (item.<Quantity>.Value * _
           item.<USPrice>.Value) > 100 _
    Order By item.<PartNumber>.Value _
    Select item

In addition to these LINQ capabilities, LINQ to XML provides an improved XML programming interface. Using LINQ to XML, you can:

  • Load XML from files or streams.

  • Serialize XML to files or streams.

  • Create XML from scratch by using functional construction.

  • Query XML using XPath-like axes.

  • Manipulate the in-memory XML tree by using methods such as Add, Remove, ReplaceWith, and SetValue.

  • Validate XML trees using XSD.

  • Use a combination of these features to transform XML trees from one shape into another.

IOne of the most significant advantages of programming with LINQ to XML is that it is easy to create XML trees. For example, to create a small XML tree, you can write C# code as follows:

XElement contacts =
    new XElement("Contacts",
        new XElement("Contact",
            new XElement("Name", "Patrick Hines"),
            new XElement("Phone", "206-555-0144", 
                new XAttribute("Type", "Home")),
            new XElement("phone", "425-555-0145",
                new XAttribute("Type", "Work")),
            new XElement("Address",
                new XElement("Street1", "123 Main St"),
                new XElement("City", "Mercer Island"),
                new XElement("State", "WA"),
                new XElement("Postal", "68042")

In Visual Basic, the code to construct the XML tree is even simpler, because it uses an XML literal:

Dim contacts = _
            <Name>Patrick Hines</Name>
            <Phone Type="Home">206-555-0144</Phone>
            <Phone Type="Work">425-555-0145</Phone>
                <Street1>123 Main St</Street1>
                <City>Mercer Island</City>

The Visual Basic compiler translates XML literals into LINQ to XML method calls.

For more information, see Creating XML Trees.

© 2015 Microsoft