Le code source présenté est en VB.NET. Le code VB.NET/C# sera téléchargeable sur le site de Tekigo. Pour tout savoir sur Nicolas Clerc ; cliquez ici.

De nos jours, les flux RSS sont devenus synonymes d’accès à de multiples sources d’informations : les blogs. Quand on utilise un outil de type portail pour gérer son blog, les flux RSS sont générés de manière automatique à partir des données saisies. Mais quid des applications ou des sources de données existantes ? Il pourtant très simple de générer ce flux RSS et de le diffuser avec .NET

Sur cette page

Création de flux RSS
La diffusion du flux RSS avec un Web Service

Création de flux RSS

Le format des flux RSS est basé sur un schéma XML standard. En voici un exemple simplifié :

<?xml version="1.0" encoding="utf-8" ?> 
<rss xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.0">
<channel>
<title>WebService et XML</title> 
<description>Tous sur XML et les Web Services</description> 
<item>
<title>Creation et diffusion d un flux RSS avec VB.NET</title> 
  <description>Comment utilisez .NET pour creer et diffuser 
un flux RSS en ecrivant un minimum de ligne de code 
VB.NET</description> 
</item>
</channel>
</rss>

Pour générer ce flux à l’aide de .NET, la première solution qui nous vient à l’esprit est l’utilisation du modèle de document XML (le DOM) implémenté dans les classes de l’espace de nom System.XML. Cette solution fonctionnerait, mais nécessiterait l’écriture de quelques lignes code pour remplir le document XML.

Une autre solution, moins évidente mais toute aussi puissante est d’utiliser la sérialisation .NET afin de créer ce flux XML directement en sérialisant une classe.NET (l’exemple est en VB.NET, mais cela fonctionne aussi avec tout autre langage .NET).

La classe pour l’élément RSS ‘Item’ ressemblera logiquement à cela :

Public Class RSSItem
    Public Property Title() As String
        Get
            Return _title
        End Get
        Set(ByVal value As String)
            _title = value
        End Set
    End Property
    Private _title As String


    Public Property Description() As String
        Get
            Return _description
        End Get
        Set(ByVal value As String)
            _description = value
        End Set
    End Property
    Private _description As String

End Class

La sérialisation XML de cette classe se fait à l’aide du code suivant :

Dim item As New Tekigo.Blog.RSSItem
item.Description = "Contenu du message"
item.Title = "Titre du message"

Dim xmlSer As System.Xml.Serialization.XmlSerializer
xmlSer = New System.Xml.Serialization.XmlSerializer( 
GetType(Tekigo.Blog.RSSItem) )

Dim sw As System.IO.StringWriter = New 
System.IO.StringWriter
xmlSer.Serialize(sw, item)

Dim itemEnXml As String = sw.ToString()

Ce qui permet de récupérer le flux XML :

<?xml version="1.0" ?> 
<RSSItem xmlns:xsi="http://www.w3.org/2001/XMLSchema-
instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<Title>Titre du message</Title> 
<Description>Contenu du message</Description>
</RSSItem>

On retrouve bien les différentes valeurs affectées aux propriétés Title et Description. Le nom des éléments XML Title et Description correspond au nom des propriétés qui ont été sérialisées. Il s’agit du comportement par défaut de la sérialisation XML en .NET.

Or une différence minime mais significative apparait : les éléments XML générés commencent par une majuscule, ce qui est problématique car XML est sensible à la casse (une lettre en majuscule n’est pas équivalente à la minuscule de la même lettre).

De plus, l’élément XML item n’apparait pas dans le flux, ce qui est normal car notre classe se nomme RSSItem. La solution la plus rapide serait de renommer la classe, mais cela risque de rentrer en conflit avec des règles de nommage pratiqué dans l’entreprise.

Le plus simple est de modifier les règles de sérialisation par défaut. Comment ? Tout simplement en ajoutant des attributs (sorte de méta-données applicable sur des éléments du code .NET) sur notre classe. Ainsi, la déclaration de la classe deviendra :

<Xml.Serialization.XmlRoot("item")> _
Public Class RSSItem

    <Xml.Serialization.XmlElement("title")> _
    Public Property Title() As String
        ' ...
    End Property


    <Xml.Serialization.XmlElement("description")> _
    Public Property Description() As String
        ' ...
    End Property

End Class

Ce qui donnera une fois sérialisé en XML :

<?xml version="1.0" ?>
<item xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<title>Titre du message</title>
<description>Contenu du message</description>
</item>

On voit que le schéma RSS est maintenant respecté, tout en maintenant une indépendance vis-à-vis du nommage VB.NET.

En examinant l’exemple RSS du début, on s’aperçoit que notre élément ‘item’ est inclus dans un élément ‘channel’, lui-même inclus dans un élément ‘rss’.

Donc, en suivant le même principe, les classes VB.NET correspondantes auront l’aspect suivant :

Imports System.Xml.Serialization

<XmlRoot("rss")> _
Public Class RSSFeed

    <XmlAttribute()> _
    Public ReadOnly version As String = "2.0"

    <XmlElement("channel")> _
    Public Property Channel() As RSSChannel
        ' ...
    End Property
    Private _channel As RSSChannel

End Class

Imports System.Xml.Serialization


<XmlRoot("channel")> _
Public Class RSSChannel

    Private _channelTitle As String
    Private _channelDescription As String
    Private _channelItem As Tekigo.Blog.RSSItem

    <XmlElement("title")> _
    Public Property Title() As String
        ' ...
    End Property

    <XmlElement("description")> _
    Public Property Description() As String
        ' ...
    End Property

    Public Property Item() As Tekigo.Blog.RSSItem
        ' ...
    End Property
End Class

La sérialisation d’une instance de RSSFeed nous renverra un flux RSS prêt à être diffusé. Dernière amélioration : un flux RSS qui ne comporte qu’un seul élément n’est pas judicieux, il faut renvoyer une collection d’item. Le code VB.NET pour gérer correctement cela est relativement simple :

<XmlRoot("channel")> _
Public Class RSSChannel
     ' ...

    <XmlElement("item")> _
    Public Items As New List(Of RSSItem)

End Class

On obtient ainsi un ensemble de classe permettant de générer un flux RSS avec quasiment aucune ligne de code à écrire !!!

Haut de page

La diffusion du flux RSS avec un Web Service

La 2^e étape consiste à diffuser ce flux RSS. Un flux RSS c’est du XML et un transport sur http. Cela ne vous fait pas penser à un WebService ?

Pour diffuser un flux RSS à l’aide d’un web service, c’est extrêmement simple :

1. créer un webservice

2. créer une fonction publique qui renvoie un RSSFeed

3. ajouter l’attribut WebMethod() sur cette fonction

4. utiliser !!!!

Imports System.Web
Imports System.Web.Services
Imports System.Web.Services.Protocols

<WebService(Namespace:="http://tempuri.org/")> _
<WebServiceBinding(ConformsTo:=WsiProfiles.BasicProfile1_1)> _
<Global.Microsoft.VisualBasic.CompilerServices.DesignerGenerated()> _
Public Class blog
     Inherits System.Web.Services.WebService

    <WebMethod()> _
    Public Function RSSFeed() As Tekigo.Blog.RSSFeed
        Dim rss As New Tekigo.Blog.RSSFeed

  ' ... ici : initialiser notre classe RSS et créer les éléments

        Return rss
    End Function

End Class

La sérialisation XML et la couche WebService de .NET se chargent de toute la mécanique !

Il nous reste juste à autoriser l’appel du web service par une requête http GET pour permettre au lecteur de blog d’utiliser directement l’url : http://monsite/blog.asmx/RSSFeed

Dans la section <System.Web> du fichier web.config, il faut ajouter :

<webServices>
<protocols>
<add name="HttpGet" />
</protocols>
</webServices>

Vous pouvez maintenant consulter votre flux RSS à partir de n’importe qu’elle lecteur de flux RSS. A titre d’essai, vous pouvez utiliser le portail Live de Microsoft (http://www.live.com) et ajouter l’url de votre flux : Ca marche !Sur le flux RSS de mon blog, cela donne :

Haut de page