LINQ to XML en 10 minutos

¿Qué es LINQ to XML?

LINQ to XML es una interfaz de programación XML en memoria habilitada para LINQ.

La capacidad de consulta de LINQ to XML es comparable en cuanto a funcionalidad (aunque no en sintaxis) a XPath y XQuery. La integración de LINQ en Visual C# 2008 proporciona una escritura más rápida, comprobación en tiempo de compilación y una compatibilidad mejorada con el depurador.

LINQ to XML tiene la capacidad de usar los resultados de la consulta como parámetros en constructores de objetos XElement y XAttribute, que habilita un método eficaz para crear árboles XML. Este método, denominado construcción funcional, permite que los desarrolladores transformen fácilmente árboles XML de una forma a otra.

Construcción Funcional, Crear Arboles XML

Una de las ventajas más significativas de la programación con LINQ to XML es la facilidad con que se pueden crear árboles XML. La construcción funcional es la capacidad de crear un árbol XML en una sola instrucción y resulta ser una forma eficaz de crear elementos. A continuación se muestra un ejemplo:

    XElement pasajeros =
        new XElement("Pasajeros",
            new XElement("Pasajero",
                new XAttribute("ID", "1"),
                new XElement("Nombre", "Luis"),
                new XElement("Apellidos", "García Varela")),
            new XElement("Pasajero",
                new XAttribute("ID", "2"),
                new XElement("Nombre", "María"),
                new XElement("Apellidos", "Arias Arjona"))
    );

Resultado:

<Pasajeros>
  <Pasajero ID="1">
    <Nombre>Luis</Nombre>
    <Apellidos>García Varela</Apellidos>
  </Pasajero>
  <Pasajero ID="2">
    <Nombre>María</Nombre>
    <Apellidos>Arias Arjona</Apellidos>
  </Pasajero>
</Pasajeros>

Veamos ahora otro ejemplo en el que usamos la misma característica  de “Construcción Funcional” pero en esta ocasión el XML a construir lo obtendremos a partir de la tabla de datos Pasajeros:

XElement pasajeros =
    new XElement("Pasajeros",
        from p in db.Pasajeros
        orderby p.IdPasajero
        select 
            new XElement("Pasajero",
              new XAttribute("ID", p.IdPasajero),
              new XElement("Nombre", p.Nombre),
              new XElement("Apellidos", p.Apellidos))
    );

Resultado: El XML de resultado será similar al del ejemplo anterior con la única diferencia que tendremos tantos nodos Pasajero como registros existan en la tabla de Pasajeros.

Características Fundamentales de la Construcción Funcional:

1. El constructor XElement toma varios tipos de argumentos para el contenido. Por ejemplo, puede pasar otro objeto XElement, que se convierte en un elemento secundario. Puede pasar un objeto XAttribute, que se convierte en un atributo del elemento. O bien, puede pasar cualquier otro tipo de objeto, que se convierte en una cadena y en el contenido de texto del elemento.
2. El constructor XElement toma una matriz de params del tipo Object, de forma que puede pasar cualquier número de objetos al constructor. Esto permite crear un elemento que tiene un contenido complejo.
3. Si un objeto implementa IEnumerable(T) , se enumera la recopilación del objeto y se agregan todos los elementos de la recopilación. Si la recopilación contiene objetos XElement o XAttribute, cada elemento de la recopilación se agrega por separado. Esto es importante porque permite pasar los resultados de una consulta de LINQ al constructor.

Consultar Arboles XML

Escribir consultas será la manera más eficaz de extraer datos de un árbol XML. Además, podemos usar la consulta, combinada con la construcción funcional, para generar nuevos documentos XML diferentes del original.

XElement pasajeros = XElement.Load(@"d:\tmp\LinqToXML_Pasajeros.xml");
IEnumerable<XElement> PasajeroSelect =
    from p in pasajeros.Elements("Pasajero")
    where (string)p.Element("Nombre") == "Luis"
    select p;
foreach (XElement p in PasajeroSelect)
    Console.WriteLine((string)p.Attribute("ID") + " - " + (string)p.Element("Nombre"));

Resultado:  1 – Luis

Veamos otra forma utilizando ahora tipos anónimos y XDocument.

XDocument xDocPasajeros = XDocument.Load(@"d:\tmp\LinqToXML_Pasajeros.xml");
var PasajeroSelect =
    from p in xDocPasajeros.Descendants("Pasajero")
    where (int)p.Attribute("ID") == 1
    select new { NombreCompleto =
        (string)p.Element("Nombre") + " " +
        (string)p.Element("Apellidos")};
foreach (var p in PasajeroSelect)
    Console.WriteLine("Nombre y  Apellidos: {0}.", p.NombreCompleto);

Resultado:  Nombre y  Apellidos: Luis García Varela.

Bueno hasta aquí este vistazo generar sobre LINQ to XML, en este post solo hemos rozado la pintura de este tema, es mucho más que lo visto, pero planteamos las ideas más generales y más usadas en la practica diaria, espero te halla servido para llevarte una idea generar sobre el tema. En próximos días continuaré profundizando un poco más sobre este apasionante tema.

Artículos Relacionados:

• LINQ Introducción.
• Tipos Anónimos en LINQ.
• LINQ to Object en 10 minutos.