Compartilhar via

Visão geral de LINQ to XML

O LINQ to XML fornece uma interface de programação XML na memória que aproveita o .NET Language-Integrated Query (LINQ) Framework. O LINQ to XML usa recursos do .NET e é comparável a uma interface de programação XML do DOM (Document Object Model) atualizada e reprojetada.

O XML foi amplamente adotado como uma forma de formatar dados em muitos contextos. Por exemplo, você pode encontrar XML na Web, em arquivos de configuração, em arquivos do Microsoft Office Word e em bancos de dados.

O LINQ to XML é uma abordagem atualizada e redesenhada para a programação com XML. Ele fornece os recursos de modificação de documento na memória do DOM (Modelo de Objeto de Documento) e dá suporte a expressões de consulta LINQ. Embora essas expressões de consulta sejam sintaticamente diferentes do XPath, elas fornecem funcionalidades semelhantes.

Desenvolvedores em LINQ to XML

O LINQ to XML tem como alvo uma variedade de desenvolvedores. Para um desenvolvedor médio que só quer fazer algo, o LINQ to XML facilita o XML fornecendo uma experiência de consulta semelhante ao SQL. Com apenas um pouco de estudo, os programadores podem aprender a escrever consultas sucintas e poderosas em sua linguagem de programação de escolha.

Os desenvolvedores profissionais podem usar LINQ to XML para aumentar consideravelmente sua produtividade. Com LINQ to XML, eles podem escrever menos código que seja mais expressivo, mais compacto e mais poderoso. Eles podem usar expressões de consulta de vários domínios de dados ao mesmo tempo.

LINQ to XML é uma interface de programação XML

O LINQ to XML é uma interface de programação XML na memória e habilitada para LINQ que permite que você trabalhe com XML de dentro das linguagens de programação do .NET.

LINQ to XML é como o DOM (Document Object Model) em que ele traz o documento XML para a memória. Você pode consultar e modificar o documento e, depois de modificá-lo, poderá salvá-lo em um arquivo ou serializá-lo e enviá-lo pela Internet. No entanto, LINQ to XML difere do DOM:

  • Ele fornece um novo modelo de objeto que é mais leve e mais fácil para trabalhar com.
  • Ele aproveita os recursos de linguagem no C# e no Visual Basic.

A vantagem mais importante do LINQ to XML é a integração com o LINQ (Language-Integrated Query). Essa integração permite que você escreva consultas no documento XML na memória para recuperar coleções de elementos e atributos. A funcionalidade de consulta de LINQ to XML é comparável na funcionalidade (embora não na sintaxe) para XPath e XQuery. A integração do LINQ no C# e no Visual Basic fornece uma digitação mais forte, verificação de tempo de compilação e suporte aprimorado ao depurador.

Outra vantagem do LINQ to XML é a capacidade de usar os resultados das consultas como parâmetros nos construtores de objetos XElement e XAttribute, o que permite uma abordagem poderosa para a criação de árvores XML. Essa abordagem, chamada construção funcional, permite que os desenvolvedores transformem facilmente árvores XML de uma forma para outra.

Por exemplo, você pode ter uma ordem de compra XML típica, conforme descrito no arquivo XML de exemplo: ordem de compra típica. Usando LINQ to XML, você pode executar a consulta a seguir para obter o valor do atributo de número de parte para cada elemento de item na ordem de compra:

// Load the XML file from our project directory containing the purchase orders
var filename = "PurchaseOrder.xml";
var currentDirectory = Directory.GetCurrentDirectory();
var purchaseOrderFilepath = Path.Combine(currentDirectory, filename);

XElement purchaseOrder = XElement.Load(purchaseOrderFilepath);

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

' Load the XML file from our project directory containing the purchase orders
Dim filename = "PurchaseOrder.xml"
Dim currentDirectory = Directory.GetCurrentDirectory()
Dim purchaseOrderFilepath = Path.Combine(currentDirectory, filename)

Dim purchaseOrder As XElement = XElement.Load(purchaseOrderFilepath)

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

Em C#, isso pode ser reescrito na forma de sintaxe do método:

IEnumerable<string> partNos = purchaseOrder.Descendants("Item").Select(x => (string) x.Attribute("PartNumber"));

Como outro exemplo, talvez você queira uma lista, classificada por número de parte, dos itens com um valor maior que US$ 100. Para obter essas informações, você pode executar a seguinte consulta:

// Load the XML file from our project directory containing the purchase orders
var filename = "PurchaseOrder.xml";
var currentDirectory = Directory.GetCurrentDirectory();
var purchaseOrderFilepath = Path.Combine(currentDirectory, filename);

XElement purchaseOrder = XElement.Load(purchaseOrderFilepath);

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

' Load the XML file from our project directory containing the purchase orders
Dim filename = "PurchaseOrder.xml"
Dim currentDirectory = Directory.GetCurrentDirectory()
Dim purchaseOrderFilepath = Path.Combine(currentDirectory, filename)

Dim purchaseOrder As XElement = XElement.Load(purchaseOrderFilepath)

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

Novamente, em C#, isso pode ser reescrito na forma de sintaxe do método:

IEnumerable<XElement> pricesByPartNos = purchaseOrder.Descendants("Item")
                                        .Where(item => (int)item.Element("Quantity") * (decimal)item.Element("USPrice") > 100)
                                        .OrderBy(order => order.Element("PartNumber"));

Além desses recursos LINQ, o LINQ to XML fornece uma interface de programação XML aprimorada. Usando LINQ to XML, você pode:

  • Carregue XML de arquivos ou fluxos.
  • Serializar o XML em arquivos ou fluxos.
  • Crie XML do zero usando a construção funcional.
  • Consultar XML usando eixos semelhantes a XPath.
  • Manipule a árvore XML na memória usando métodos como Add, , Removee ReplaceWithSetValue.
  • Valide árvores XML usando XSD.
  • Use uma combinação desses recursos para transformar árvores XML de uma forma em outra.

Criar árvores XML

Uma das vantagens mais significativas da programação com LINQ to XML é que é fácil criar árvores XML. Por exemplo, para criar uma árvore XML pequena, você pode escrever código da seguinte maneira:

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")
        )
    )
);

Dim contacts As XElement = _
    <Contacts>
        <Contact>
            <Name>Patrick Hines</Name>
            <Phone>206-555-0144</Phone>
            <Address>
                <Street1>123 Main St</Street1>
                <City>Mercer Island</City>
                <State>WA</State>
                <Postal>68042</Postal>
            </Address>
        </Contact>
    </Contacts>

Observação

A versão do Visual Basic do exemplo usa literais do XML. Você também pode usar XElement no Visual Basic, como na versão C#.

Para obter mais informações, consulte árvores XML.

Consulte também