Scour Design. Tutoriales de Flash, ActionScript, CSS, Photoshop, ImageReady...

\n"; } } } lecturas();

          


RSS 2.0 Dinámicamente. XmlTextWriter (Visual C#)

      

Autor: Carlos Carmona

Para empezar, una pequeña explicación sobre qué es RSS.

RSS
RSS es parte de la familia de los formatos XML desarrollado específicamente para sitios de noticias y weblogs que se actualizan con frecuencia y por medio del cual se puede compartir la información y usarla en otros sitios web o programas. A esto se le conoce como sindicación.

La cantidad de utilidades que se le han encontrado al lenguaje XML no deja de sorprenderme, y la de RSS en particular brinda una gran herramienta en estos tiempos en los que estamos rodeados de tantísima información, absolutamente inabarcable. Con nuestro software favorito podemos sindicar aquellas webs que nos interesan de modo que de un solo vistazo podamos ver si hay algo que nos interese e ir directo a ello, dejando de lado lo que no y evitando perder mucho tiempo navegando en busca de nuestro objetivo.

Hacer un documento RSS, por supuesto dinámico, en .NET, es sencillo una vez conocida la sintaxis, veamos como...

Para que el método sea lo más portable posible, vamos a segmentarlo todo en funciones. Por un lado, el evento donde se desencadenará la acción de crear el documento, que será el Page_Load, y dentro de este se llamará a 3 funciones, una que creará el encabezado, otra que irá añadiendo los elementos y una tercera que cerrará el documento.

Vamos con el evento:

    

  1. 
private void Page_Load(object sender, System.EventArgs e)

    2. 

  2. {
    3. 

  3. 	//Declaramos el objeto XML (o escritor de XML)

    4. 

  4. 	//donde crearemos el documento RSS 2.0

    5. 

  5. 	XmlTextWriter Escritor = new XmlTextWriter(Response.OutputStream, 
       System    .Text.Encoding.UTF8);
    6. 

  6. 	//********************************************

    7. 

  7.  
    8. 

  8. 	//Escribimos la cabecera del documento

    9. 

  9. 	EscribirInicioRSS(Escritor);
    10. 

  10. 	//************************************

    11. 

  11.  
    12. 

  12. 	//Añadimos los elementos. Aquí los he añadido 'a pelo',

    13. 

  13. 	//sin embargo, lo suyo sería hacer un bucle que se repita

    14. 

  14. 	//tantas veces como elementos queramos añadir y que

    15. 

  15. 	//dichos elementos se obtengan de un DataSet de Base de Datos

    16. 

  16. 	AddElementosRSS(Escritor,"<strong>Título 1</strong>",
    "/index.html","Descripción 1 - Sin CDATA");
    17. 

  17. 	AddElementosRSS(Escritor,"<strong>Título 2</strong>",
       "/articulos/index.html"    ,"Descripción 2 - Sin CDATA");
    18. 

  18. 	AddElementosRSS(Escritor,"<strong>Título 3</strong>",
    "/principal.html","Descripción 3 - Con CDATA", true);
    19. 

  19. 	AddElementosRSS(Escritor,"<strong>Título 4</strong>",
    "/articulos/tutoriales/css/index.html","Descripción 4 - Con CDATA", 
    true);
    20. 

  20. 	//***********************************************************

    21. 

  21. 	
    22. 

  22. 	//Cerramos el documento RSS

    23. 

  23. 	EscribirFinRSS(Escritor);
    24. 

  24. 	//*************************

    25. 

  25. 	
    26. 

  26. 	//Volcamos el contenido en el objeto y lo cerramos

    27. 

  27. 	Escritor.Flush();
    28. 

  28. 	Escritor.Close();
    29. 

  29. 	//************************************************

    30. 

  30.     
    31. 

  31. 	//Especificamos la codificación del

    32. 

  32. 	//documento y habilitamos la caché

    33. 

  33. 	Response.ContentEncoding = System.Text.Encoding.UTF8;
    34. 

  34. 	Response.ContentType = "text/xml";
    35. 

  35. 	Response.Cache.SetCacheability(HttpCacheability.Public);
    36. 

  36. 	//*********************************

    37. 

  37.  
    38. 

  38. 	//Enviamos al cliente la salida del buffer

    39. 

  39. 	Response.End();
    40. 

  40. 	//****************************************

    41. 

  41. 
} 
    42.

Como se vé, y aunque el código ya está comentado, un breve resumen:

Vamos a ver estas 3 funciones, que son las que realmente construyen el documento (la explicación va en los comentarios de los propios códigos):

Función EscribirInicioRSS()

    

  1. /// <summary>
    2. 

  2. /// Escribe el principio de un documento RSS a un XmlTextWriter
    3. 

  3. /// </summary>
    4. 

  4. /// <param name="Escritor">El XmlTextWriter donde se escribirá</param>
    5. 

  5. /// <returns>El XmlTextWriter con la información de cabecera ya escrita</returns>
    6. 

  6. 
public XmlTextWriter EscribirInicioRSS(XmlTextWriter Escritor)

    7. 

  7. {
    8. 

  8. 	//Abrimos el documento

    9. 

  9. 	Escritor.WriteStartDocument();
    10. 

  10. 	//********************

    11. 

  11.  
    12. 

  12. 	//Si se desea añadir un comentario al archivo RSS:

    13. 

  13. 	Escritor.WriteComment("Comentario de prueba");
    14. 

  14. 	//************************************************

    15. 

  15.  
    16. 

  16. 	//El primer elemento a añadir será la declaración del RSS

    17. 

  17. 	Escritor.WriteStartElement("rss");
    18. 

  18. 	Escritor.WriteAttributeString("version","2.0");
    19. 

  19. 	Escritor.WriteAttributeString("xmlns:blogChannel",
    "http://backend.userland.com/blogChannelModule");
    20. 

  20. 	//*******************************************************

    21. 

  21.  
    22. 

  22. 	//Definimos el elemento 'padre'

    23. 

  23. 	Escritor.WriteStartElement("channel");
    24. 

  24. 	//*****************************

    25. 

  25.  
    26. 

  26. 	//Si queremos añadir algún elemento inicial independiente

    27. 

  27. 	//de los contenidos, como que web somos, copyright, etc:

    28. 

  28. 	Escritor.WriteElementString("title",
    "Documento RSS generado dinámicamente en .NET");
    29. 

  29. 	Escritor.WriteElementString("link",
    "/articulos/tutoriales/net/index.html");
    30. 

  30. 	Escritor.WriteElementString("description",
       "Un método para escribir documentos RSS en .NET con C#"    );
    31. 

  31. 	//*******************************************************

    32. 

  32.  
    33. 

  33. 	//Devolvemos el objeto XML (RSS) con la cabecera ya escrita

    34. 

  34. 	return Escritor;
    35. 

  35. 	//*********************************************************

    36. 

  36. 
} 
    37.

Función AddElementosRSS() con 2 'Sobre Cargas'

Primera 'Sobre Carga'

    

  1. /// <summary>
    2. 

  2. /// Añade un elemento al XmlTextWriter pasado
    3. 

  3. /// </summary>
    4. 

  4. /// <param name="Escritor">El XmlTextWriter donde se escribirá</param>
    5. 

  5. /// <param name="CadenaTitulo">El título del elemento RSS</param>
    6. 

  6. /// <param name="CadenaLink">La URL del elemento actual</param>
    7. 

  7. /// <param name="CadenaDescrip">Descripción del elemento</param>
    8. 

  8. /// <returns>El XmlTextWriter con el nuevo elemento escrito en él</returns>
    9. 

  9. 
public XmlTextWriter AddElementosRSS(XmlTextWriter Escritor, string CadenaTitulo,
    string CadenaLink, string CadenaDescrip)

    10. 

  10. {
    11. 

  11. 	//Abrímos un nuevo elemento

    12. 

  12. 	Escritor.WriteStartElement("item");
    13. 

  13. 	//*************************

    14. 

  14.  
    15. 

  15. 	//Añadimos los elementos hijos del actual objeto

    16. 

  16. 	Escritor.WriteElementString("title",CadenaTitulo);
    17. 

  17. 	Escritor.WriteElementString("link",CadenaLink);
    18. 

  18. 	Escritor.WriteElementString("description",CadenaDescrip);
    19. 

  19. 	Escritor.WriteElementString("pubdate", DateTime.Now.ToString("r"));
    20. 

  20. 	//**********************************************

    21. 

  21.  
    22. 

  22. 	//Cerramos el elemento

    23. 

  23. 	Escritor.WriteEndElement();
    24. 

  24. 	//********************

    25. 

  25.  
    26. 

  26. 	//Devolvemos el objeto XML (RSS) con el elemento añadido

    27. 

  27. 	return Escritor;
    28. 

  28. 	//******************************************************

    29. 

  29. 
} 
    30.

Segunda 'Sobre Carga'

    

  1. /// <summary>
    2. 

  2. /// Añade un elemento al XmlTextWriter pasado
    3. 

  3. /// </summary>
    4. 

  4. /// <param name="Escritor">El XmlTextWriter donde se escribirá</param>
    5. 

  5. /// <param name="CadenaTitulo">El título del elemento RSS</param>
    6. 

  6. /// <param name="CadenaLink">La URL del elemento actual</param>
    7. 

  7. /// <param name="CadenaDescrip">Descripción del elemento</param>
    8. 

  8. /// <param name="BoolDescriptCDATA">Escribe la descripción como CDATA</param>
    9. 

  9. /// <returns>El XmlTextWriter con el nuevo elemento escrito en él</returns>
    10. 

  10. 
public XmlTextWriter AddElementosRSS(XmlTextWriter Escritor, string CadenaTitulo, 
    string CadenaLink, string CadenaDescrip, bool BoolDescriptCDATA)

    11. 

  11. {
    12. 

  12. 	//Abrímos un nuevo elemento

    13. 

  13. 	Escritor.WriteStartElement("item");
    14. 

  14. 	//*************************

    15. 

  15.  
    16. 

  16. 	//Añadimos los elementos hijos del actual objeto

    17. 

  17. 	Escritor.WriteElementString("title",CadenaTitulo);
    18. 

  18. 	Escritor.WriteElementString("link",CadenaLink);
    19. 

  19.  
    20. 

  20. 	//Si así lo hemos especificado, la

    21. 

  21. 	//descripción de añadirá como CDATA

    22. 

  22. 	if (BoolDescriptCDATA == true)

    23. 

  23. 	{

    24. 

  24. 		Escritor.WriteStartElement("description");  
    25. 

  25. 		Escritor.WriteCData(CadenaDescrip);			
    26. 

  26. 		Escritor.WriteEndElement();
    27. 

  27. 	}

    28. 

  28. 	else

    29. 

  29. 	{

    30. 

  30. 		Escritor.WriteElementString("description",CadenaDescrip);
    31. 

  31. 	}

    32. 

  32. 	//*********************************

    33. 

  33.  
    34. 

  34. 	Escritor.WriteElementString("pubdate", DateTime.Now.ToString("r"));
    35. 

  35. 	//**********************************************

    36. 

  36.  
    37. 

  37. 	//Cerramos el elemento

    38. 

  38. 	Escritor.WriteEndElement();
    39. 

  39. 	//********************

    40. 

  40.  
    41. 

  41. 	//Devolvemos el objeto XML (RSS) con el elemento añadido

    42. 

  42. 	return Escritor;
    43. 

  43. 	//******************************************************

    44. 

  44. 
} 
    45.

Si os fijais en el código del Page_Load. vereis que de las 4 llamadas que se hacen a esta función (AddElementosRSS()) , las 2 primeras tienen 4 parámetros, y las 2 siguientes tienen un quinto parametro de tipo booleano (true o false). Las llamadas con 4 parametros ejecutarán la primera 'Sobre Carga', que inserta un nuevo item de forma normal; si añadimos el quinto parámetro, y este es 'true', lo que haremos será que la descripción se escriba como CDATA, básicamente para que el XML no interprete ciertos caracteres como propios de su lenguaje y trate de ejecutarlos, es decir, para que escriba el texto tal y como está. Si utilizamos el quinto parametro pero lo especificamos a 'false' estaremos haciendo lo mismo que si llamásemos a la primera 'Sobre Carga'.

Función EscribirFinRSS()

    

  1. /// <summary>
    2. 

  2. /// Finalmente, cerramos los elementos del RSS y el documento en sí
    3. 

  3. /// </summary>
    4. 

  4. /// <param name="Escritor">El XmlTextWriter donde se escribirá</param>
    5. 

  5. /// <returns>El XmlTextWriter con todos los elementos cerrados</returns>
    6. 

  6. 
public XmlTextWriter EscribirFinRSS(XmlTextWriter Escritor)

    7. 

  7. {
    8. 

  8. 	//Cerramos los elementos abiertos y el documento

    9. 

  9. 	Escritor.WriteEndElement();
    10. 

  10. 	Escritor.WriteEndElement();
    11. 

  11. 	Escritor.WriteEndDocument();
    12. 

  12. 	//**********************************************

    13. 

  13.  
    14. 

  14. 	//Devolvemos el objeto con todo el documento ya escrito

    15. 

  15. 	return Escritor;
    16. 

  16. 	//*****************************************************

    17. 

  17. 
} 
    18.

Simplemente, copiar y pegar el contenido del evento Page_Load y las 4 funciones, ya que si copiais los códigos de aquí os llevareis también el html, podeis copiarlo de aquí.

Y con esto hemos terminado, ya tenemos implementado en nuestra web un sistema RSS dinámico para que sindicalicen nuestros contenidos.

Espacio de nombre requerido:
    

  1. 
using System.IO;
    2. 

  2. 
using System.Xml; 
    3.
Scour Design ™ Todos los Derechos Reservados © Carlos Carmona Xhtml 1.1 Strict Válido!CSS Nivel 2 Válido! Nivel Triple-A de Conformidad con las Directrices de Accesibilidad Web (WAI)