Modificación del árbol XML en memoria frente a construcción funcional (LINQ to XML)

Modificar un árbol XML en su lugar es un enfoque tradicional para cambiar la forma de un documento XML. Una aplicación típica carga un documento en un almacén de datos como DOM o LINQ to XML; utiliza una interfaz de programación para insertar o eliminar nodos, o cambiar su contenido; y, a continuación, guarda el XML en un archivo o lo transmite a través de una red.

LINQ to XML permite otro enfoque que resulta útil en muchos escenarios: construcción funcional. La construcción funcional trata la modificación de datos como un problema de transformación, en lugar de como manipulación detallada de un almacén de datos. Si puede tomar una representación de los datos y transformarlos de forma eficaz de un formulario a otro, el resultado es el mismo que si tomó un almacén de datos y lo manipuló de alguna manera para tomar otra forma. Un aspecto clave del enfoque de construcción funcional es pasar los resultados de las consultas a los constructores XDocument y XElement.

En muchos casos, puede escribir el código de transformación en una fracción del tiempo que tardaría en manipular el almacén de datos y el código resultante es más sólido y fácil de mantener. En estos casos, aunque el enfoque de transformación pueda tomar más potencia de procesamiento, es una manera más eficaz de modificar los datos. Si un desarrollador está familiarizado con el enfoque funcional, el código resultante en muchos casos es más fácil de entender y es fácil encontrar el código que modifica cada parte del árbol.

El enfoque en el que se modifica un árbol XML en su lugar es más familiar para muchos programadores dom, mientras que el código escrito con el enfoque funcional podría parecer desconocido para un desarrollador que aún no entiende ese enfoque. Si solo tiene que realizar una pequeña modificación en un árbol XML grande, el enfoque en el que se modifica un árbol directamente en muchos casos consumirá menos tiempo de CPU.

En este artículo se proporcionan ejemplos de ambos enfoques. Supongamos que desea modificar el siguiente documento XML simple para que los atributos se conviertan en elementos:

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

En el primero de los ejemplos siguientes se usa el enfoque de modificación local tradicional y el segundo usa el enfoque de construcción funcional.

Ejemplo: Transformar atributos en elementos con el enfoque in situ tradicional

Puede escribir código de procedimientos para crear elementos a partir de los atributos y, a continuación, eliminar los atributos, como se indica a continuación:

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)

En este ejemplo se genera la siguiente salida:

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

Ejemplo: Transformación de atributos en elementos con el enfoque de construcción funcional

Por el contrario, un enfoque funcional consiste en código para formar un nuevo árbol, seleccionar y elegir elementos y atributos del árbol de origen y transformarlos según corresponda cuando se agreguen al nuevo árbol.

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)

En este ejemplo se genera el mismo XML que el primer ejemplo. Sin embargo, tenga en cuenta que puede ver efectivamente la estructura resultante del nuevo XML mediante el enfoque funcional. Puede ver la creación del Root elemento, el código que extrae el Child1 elemento del árbol de origen y el código que transforma los atributos del árbol de origen en elementos del nuevo árbol.

El ejemplo funcional en este caso no es más corto ni más sencillo que el primer ejemplo. Sin embargo, si tiene muchos cambios para realizar en un árbol XML, el enfoque procedimental se convertirá en bastante complejo y algo obtuso. Por el contrario, al usar el enfoque funcional, sigue formando el XML deseado, insertando consultas y expresiones según corresponda, para extraer el contenido deseado. El enfoque funcional produce código que es más fácil de mantener.

Tenga en cuenta que, en este caso, el enfoque funcional probablemente no funcionaría tan bien como el enfoque de manipulación de árboles. El problema principal es que el enfoque funcional crea objetos más de corta duración. Sin embargo, el equilibrio es eficaz si el uso del enfoque funcional permite una mayor productividad del programador.

Este es un ejemplo muy sencillo, pero sirve para mostrar la diferencia en la filosofía entre los dos enfoques. El enfoque funcional produce mayores ganancias de productividad para transformar documentos XML más grandes.