Ultimos Posts:

Tenía ganas de comenzar a picar algo de código utilizando LINQ... algo simple, quizás un poco tonto, pero que me sirviera de verdad: automatizar la creación del fichero XML RSS de mi sitio web.

Vale... se que hay disponibles herramientas profesional que hacen esto, o freeware, o lo que sea..., pero con esto tenía la oportunidad de combinar LINQ to SQL (para leer de mi base de datos), y LINQ To XML (para generar la salida XML)... y poder darme cuenta de que con sólo cinco líneas de código tenía esto funcionando con LINQ !!

Comencemos por definir el escenario:

Vamos a definir nuestra necesidad de negocio: para dar a conocer nuestro sitio vamos a publicar un fichero XML RSS de forma que otros sitios web o portales puede leerlo y publicar un sumario de los artículos / post que tenemos diponibles en nuestro blog. El Feed que vamos a generar tiene la siguiente estructura:

            
    <?xml version="1.0" encoding="utf-8" standalone="yes"?>
    <rss version="2.0">
        <channel>
            <title>Nombre del sitio</title>
            <description>Descripción del sitio.</description>
            <link>http://www.mysite.com</link>

            <item>
                <title>Titulo del post</title>
                <link>http://www.mysite.com?ID=12</link>
                <pubDate>2007-11-24T08:12:24.323Z</pubDate>
                <description> descripcion corta del post</description>
            </item>
            
            <item>
            ... Title / link / pubDate / Description ...
            </item>
            (...) Un montón de entradas... (una por articulo)
       </channel>
    </rss>
    

Lo que tenemos que implementar: Leer de la tabla de artículos todas las entradas (campo: title, pubDate y RSSDescription) , crear un XML RSS Feed y insertar todas las filas que leamos de la base de datos volcandolas en formato XML RSS.

Commencemos a picar código:

Crea un nuevo proyecto Visual Studio, aplicación de consola, (File >> New Project):

Añadimos un nuevo item al proyecto, vamos a crear un item del tipo LINQ DBML (lo llamaremos SampleDB):

En el Server Explorer >> añadimos una conexión a nuestra base de datos SQL Server (ojo, parece que LINQ to SQL no soporta todavía Ms Access). Hacemos double click sobre el fichero LINQ DBML que creamos en el paso anterior, y hacemos drop de la tabla que queremos visualizar (la que contiene los artículos):

Clicamos en los items del DBML (título de la tabla, campos...) y renombramos los nombres de los campos a nombres amistosos (estamos usando entidades, no hay necesidad de guardar los nombores horribles con prefijos de la base de datos), y tambíen borramos los campos que no vayamos a usar (por ejemplo el campo content).

Graba y cierra el DBML.

(*) A tener en cuenta: el connectionstring se guarda en fichero DBML de forma no segura, tienes que elegir entre usar seguridad integrada windows o no almancenar el usuario y password, en código puedes utilizar la propiedad del data context db.Connection.ConnectionString para indicarle la conexión a base de datos en tiempo de ejecución (podrías por ejemplo almacenarla en el web.config cifrandola).

Antes de comenzar a codificar, aseguremonos que tenemos todas las referencias que necesitamos para utilizar LINQ y LINQ XML:

y que tenemos todos los "using" declarados en el fichero cs.

    
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Xml.Linq;
    using System.Text;    
    

Vamos ahora a instanciar el DBConext asociado al DBML que acabamos de crear. Leeremos todas las entradas de artículos que necesitemos:

       // InstanciamosInstantiate the SampleDBDataContext (basado en el dbml que hemos creado 

previamente).
        SampleDBDataContext db = new SampleDBDataContext();

        // Asumamos que nuestro sitio referencia a los artículos de la 
        // siguiente forma: http://www.mysite.com/Article.aspx?ID=99            
        string blogURLENG = "http://www.mysite.com/Article.aspx?BLID={0}";

        // Primero crearemos todos los nodos XML que referencian a los artículos, 
        // tendremos una subestructura XML como la que sigue(una colección de items, una por
        // por artículo/post):
        // 
        // <item>
        //    <title>Titulo del post</title>
        //    <link>http://www.mysite.com.com?ID=12</link>
        //    <pubDate>2007-11-24T08:12:24.323Z</pubDate>
        //    <description> resumen del contenido del post</description>
        // </item>

        var articlesEntries = from p in db.BlogEntries
                                   orderby p.EntryDate
                                   select new XElement("item",
                                                            new XElement("title", p.Title),
                                                            new XElement("link", 

string.Format(blogURLENG, p.ID)),
                                                            new XElement("pubDate", 

p.EntryDate.ToUniversalTime()),
                                                            new XElement("description", 

p.RSSDescription)
                                                            
                                                      );
    

Aquí lo que hago es ejecutar una SELECT (utilizando sintaxis de LINQ) sacar los campos y filas que necesito, y encapsular el resultado una estructura XElement (un trozo de XML que utiliza la estructura RSS). Como puedes apreciar, no me quiero preocupar de que tipo es la variable que me devuelve la consulta, se que es una lista de elementos XElement y que implementa el interfaz IEnumerable, con eso tengo bastante, lo declaro como "var" y me olvido de adivinar de que tipo es (Visual Studio lo hace por mi :-)).

Vamos a crear el armazon completo XML para el RSS e inyectar el trozo de XML con los artículos que acabamos de generar hace un momentito:

      // Vamos a colocar el subarbol XML de artículos en la estructura completa 
      // del documento XML
      //
      // <?xml version="1.0" encoding="utf-8" standalone="yes"?>
      // <rss version="2.0">
      // <channel>
      //    <title>Nombre del sitio</title>
      //    <description>Descripcion del stio.</description>
      //    <link>http://www.mysite.com</link>
      //  <item>
      //     ...Información sobre un artículo (esto lo hemos creado antes) 
      //  </item>
      //  (...) Un montón de items... (uno por artículo / post)
      //  </channel>
      //
      // Como puedes apreciar, podemos declarar en el mismo constructor la 
      // estructura del XMl, añadir elementos (como channel),
      // que de estos elementos cuelguen otros, e incluso indicar que
      // de uno de estos elementos cuelgan una lista de XML (artículos)      
      XDocument doc = new XDocument(
          new XDeclaration("1.0", "utf-8", "yes"),                
          new XElement("rss",
              new XAttribute("version", "2.0"),
              new XElement("channel",
                  new XElement("title", "RSS Mi sitio de ejemplo"),
                  new XElement("description", "Descripcion de misitio.com."),
                  new XElement("link", "http://www.mysite.com"),
                  articlesEntries
                  )
              )
           );
    

Impresionante ¿verdad? En una lína de código hemos definido el XML, sus elementos principales y le hemos enganchado nuestra lista de artículos.

Siguiente paso, grabar el documento generado...

            
    // Grabar el XML resultante en un fichero
    doc.Save(@"rss.xml");    
    

Como dije al principio del post, ... aquí tienes un generador RSS simple ¡¡ en sólo cinco líneas de código !!