Modificação de árvore XML na memória versus construção funcional (LINQ to XML)

Modificar uma árvore XML no local é uma abordagem tradicional para alterar a forma de um documento XML. Um aplicativo típico carrega um documento em um armazenamento de dados, como DOM ou LINQ to XML; usa uma interface de programação para inserir ou excluir nós ou alterar seu conteúdo; e, em seguida, salva o XML em um arquivo ou transmite-o por uma rede.

LINQ to XML habilita outra abordagem que é útil em muitos cenários: a construção funcional. A construção funcional trata a modificação de dados como um problema de transformação, em vez de uma manipulação detalhada de um armazenamento de dados. Se você pode ter uma representação dos dados e a transformação com eficiência de um formulário para outro, o resultado é o mesmo como se você recebe um armazenamento de dados e o manipulou de alguma maneira para executar outra forma. Uma chave para a abordagem de construção funcional é passar os resultados de consultas para os construtores XDocument e XElement.

Em muitos casos, você pode escrever o código de transformação em uma fração do tempo necessário para manipular o armazenamento de dados e o código resultante é mais robusto e fácil de manter. Nesses casos, embora a abordagem transformadora possa ter mais poder de processamento, é uma maneira mais eficaz de modificar dados. Se um desenvolvedor estiver familiarizado com a abordagem funcional, o código resultante em muitos casos será mais fácil de entender e é fácil encontrar o código que modifica cada parte da árvore.

A abordagem em que você modifica uma árvore XML no local é mais familiar para muitos programadores DOM, enquanto o código escrito usando a abordagem funcional pode parecer desconhecido para um desenvolvedor que ainda não entende essa abordagem. Se você precisar fazer apenas uma pequena modificação em uma árvore XML grande, a abordagem em que você modifica uma árvore no local, em muitos casos, levará menos tempo de CPU.

Este artigo fornece exemplos de ambas as abordagens. Suponha que você queira modificar o seguinte documento XML simples para que os atributos se tornem elementos:

<?xml version="1.0" encoding="utf-8" ?>
<Root Data1="123" Data2="456">
  <Child1>Content</Child1>
</Root>

O primeiro dos exemplos a seguir usa a abordagem de modificação local tradicional e o segundo usa a abordagem de construção funcional.

Exemplo: transformar atributos em elementos com a abordagem in-loco tradicional

Você pode escrever algum código de procedimento para criar elementos dos atributos e, em seguida, excluir os atributos, da seguinte maneira:

XElement root = XElement.Load("Data.xml");
foreach (XAttribute att in root.Attributes()) {
    root.Add(new XElement(att.Name, (string)att));
}
root.Attributes().Remove();
Console.WriteLine(root);

Dim root As XElement = XElement.Load("Data.xml")
For Each att As XAttribute In root.Attributes()
    root.Add(New XElement(att.Name, att.Value))
Next
root.Attributes().Remove()
Console.WriteLine(root)

Este exemplo produz a seguinte saída:

<Root>
  <Child1>Content</Child1>
  <Data1>123</Data1>
  <Data2>456</Data2>
</Root>

Exemplo: transformar atributos em elementos com a abordagem de construção funcional

Por outro lado, uma abordagem funcional consiste em código para formar uma nova árvore, escolher elementos e atributos da árvore de origem e transformá-los conforme apropriado conforme eles são adicionados à nova árvore.

XElement root = XElement.Load("Data.xml");
XElement newTree = new XElement("Root",
    root.Element("Child1"),
    from att in root.Attributes()
    select new XElement(att.Name, (string)att)
);
Console.WriteLine(newTree);

Dim root As XElement = XElement.Load("Data.xml")
Dim newTree As XElement = _
    <Root>
        <%= root.<Child1> %>
        <%= From att In root.Attributes() _
            Select New XElement(att.Name, att.Value) %>
    </Root>
Console.WriteLine(newTree)

Este exemplo gera o mesmo XML do primeiro exemplo. No entanto, observe que você pode realmente ver a estrutura resultante do novo XML na abordagem funcional. Você pode ver a criação do Root elemento, o código que extrai o Child1 elemento da árvore de origem e o código que transforma os atributos da árvore de origem em elementos na nova árvore.

O exemplo funcional nesse caso não é mais curto nem simples do que o primeiro exemplo. No entanto, se você tiver muitas alterações a serem feitas em uma árvore XML, a abordagem processual se tornará bastante complexa e um pouco obtusa. Por outro lado, ao usar a abordagem funcional, você simplesmente forma o XML desejado, inserindo consultas e expressões conforme apropriado, para obter o conteúdo desejado. A abordagem funcional produz um código mais fácil de manter.

Observe que, nesse caso, a abordagem funcional provavelmente não teria um desempenho tão bom quanto a abordagem de manipulação de árvore. O principal problema é que a abordagem funcional cria mais objetos de curta duração. No entanto, a compensação será efetiva se o uso da abordagem funcional permitir maior produtividade do programador.

Este é um exemplo muito simples, mas serve para mostrar a diferença na filosofia entre as duas abordagens. A abordagem funcional gera maiores ganhos de produtividade para transformar documentos XML maiores.