Flux RSS/Atom

API importantes

• Windows. Data.Xml.Dom
• Windows. Web.AtomPub
• Windows. Web.Syndication

Récupérez ou créez le contenu Web le plus récent et le plus populaire à l’aide de flux syndiqués générés conformément aux normes RSS et Atom grâce aux fonctionnalités de l’espace de noms Windows.Web.Syndication.

Qu’est-ce qu’un flux ?

Un flux web est un document qui contient un nombre quelconque d’entrées individuelles composées de texte, de liens et d’images. Les mises à jour apportées à un flux sont sous la forme de nouvelles entrées utilisées pour promouvoir le contenu le plus récent sur le web. Les consommateurs de contenu peuvent utiliser une application de lecteur de flux pour agréger et surveiller les flux à partir de n’importe quel nombre d’auteurs de contenu individuels, en accédant rapidement et facilement au contenu le plus récent.

Quelles sont les normes de format de flux prises en charge ?

Windows prend en charge la récupération de flux pour les normes de format RSS de 0,91 à RSS 2.0 et atom de 0.3 à 1.0. Les classes de l’espace de noms Windows.Web.Syndication peuvent définir des flux et des éléments de flux capables de représenter à la fois des éléments RSS et Atom.

En outre, les formats Atom 1.0 et RSS 2.0 permettent à leurs documents de flux de contenir des éléments ou des attributs non définis dans les spécifications officielles. Au fil du temps, ces éléments et attributs personnalisés sont devenus un moyen de définir des informations spécifiques au domaine consommées par d’autres formats de données de service web tels que GData et OData. Pour prendre en charge cette fonctionnalité ajoutée, la classe SyndicationNode représente des éléments XML génériques. L’utilisation de SyndicationNode avec des classes dans l’espace de noms Windows.Data.Xml.Dom permet aux applications d’accéder à des attributs, à des extensions ainsi qu’à tout contenu qu’elles peuvent contenir.

Notez que, pour la publication de contenu syndiqué, l’implémentation Windows du protocole de publication Atom (Windows). Web.AtomPub) prend uniquement en charge les opérations de contenu de flux en fonction des normes Atom et Atom Publication.

Utilisation de contenu syndiqué avec isolation réseau

La fonctionnalité d’isolation réseau dans Windows permet au développeur de contrôler et de limiter l’accès réseau par une application Windows. Toutes les applications ne peuvent pas nécessiter l’accès au réseau. Toutefois, pour ces applications, Windows fournit différents niveaux d’accès au réseau qui peuvent être activés en sélectionnant les fonctionnalités appropriées.

L’isolation réseau permet à un développeur de définir pour chaque application l’étendue de l’accès réseau requis. Une application sans l’étendue appropriée définie n’est pas empêchée d’accéder au type de réseau spécifié et à un type spécifique de requête réseau (demandes initiées par le client sortant ou à la fois des requêtes entrantes non sollicitées et des requêtes sortantes initiées par le client). La capacité à définir et à faire respecter l’isolement réseau garantit que, si une application vient à être compromise, elle ne peut accéder qu’aux réseaux auxquels elle s’est explicitement vu accorder l’accès. Cela réduit considérablement l’étendue de l’impact sur d’autres applications et sur Windows.

L’isolation réseau affecte tous les éléments de classe dans les espaces de noms Windows.Web.Syndication et Windows.Web.AtomPub qui tentent d’accéder au réseau. Windows applique activement l’isolation réseau. Un appel à un élément de classe dans l’espace de noms Windows.Web.Syndication ou Windows.Web.AtomPub qui entraîne un accès au réseau peut échouer en raison de l’isolation réseau si la fonctionnalité réseau appropriée n’a pas été activée.

Les fonctionnalités réseau d’une application sont configurées dans le manifeste de l’application lorsque l’application est générée. Les fonctionnalités réseau sont généralement ajoutées à l’aide de Visual Studio lors du développement de l’application. Les fonctionnalités réseau peuvent également être définies manuellement dans le fichier manifeste de l’application à l’aide d’un éditeur de texte.

Pour plus d’informations sur les fonctionnalités d’isolation réseau et de mise en réseau, consultez la section « Fonctionnalités » dans la rubrique Concepts de base de la mise en réseau.

Comment accéder à un flux web

Cette section montre comment récupérer et afficher un flux web à l’aide de classes dans le Windows. Espace de noms Web.Syndication dans votre application Windows écrite en C#.

Conditions préalables

Pour vous assurer que votre application Windows est prête pour le réseau, vous devez définir toutes les fonctionnalités réseau nécessaires dans le fichier Project Package.appxmanifest. Si votre application doit se connecter en tant que client aux services distants sur Internet, la fonctionnalité InternetClient est nécessaire. Pour plus d’informations, consultez la section « Fonctionnalités » dans la rubrique Concepts de base de la mise en réseau .

Récupération de contenu syndiqué à partir d’un flux web

Nous allons maintenant passer en revue du code qui montre comment récupérer un flux, puis afficher chaque élément individuel que le flux contient. Avant de pouvoir configurer et envoyer la requête, nous allons définir quelques variables que nous utiliserons pendant l'opération et initialiser une instance de SyndicationClient, qui définit les méthodes et les propriétés que nous utiliserons pour récupérer et afficher le flux.

Le constructeur d’URI lève une exception si l’uriString passé au constructeur n’est pas un URI valide. Nous validons donc l’uriString à l’aide d’un bloc try/catch.

Windows.Web.Syndication.SyndicationClient client = new Windows.Web.Syndication.SyndicationClient();
Windows.Web.Syndication.SyndicationFeed feed;
// The URI is validated by catching exceptions thrown by the Uri constructor.
Uri uri = null;
// Use your own uriString for the feed you are connecting to.
string uriString = "";
try
{
    uri = new Uri(uriString);
}
catch (Exception ex)
{
    // Handle the invalid URI here.
}

var currentFeed = null;
var currentItemIndex = 0;
var client = new Windows.Web.Syndication.SyndicationClient();
// The URI is validated by catching exceptions thrown by the Uri constructor.
var uri = null;
try {
    uri = new Windows.Foundation.Uri(uriString);
} catch (error) {
    WinJS.log && WinJS.log("Error: Invalid URI");
    return;
}

Ensuite, nous configurons la requête en définissant les informations d’identification du serveur (propriété ServerCredential ), les informations d’identification proxy (propriété ProxyCredential ) et les en-têtes HTTP (méthode SetRequestHeader ) nécessaires. Avec les paramètres de requête de base configurés, un objet Uri valide, créé à l’aide d’une chaîne d’URI de flux fournie par l’application. L’objet Uri est ensuite passé à la fonction RetrieveFeedAsync pour demander le flux.

En supposant que le contenu du flux souhaité a été retourné, l’exemple de code itère à travers chaque élément de flux, appelant displayCurrentItem (que nous définissons ensuite), pour afficher les éléments et leur contenu sous forme de liste via l’interface utilisateur.

Vous devez écrire du code pour gérer les exceptions lorsque vous appelez la plupart des méthodes réseau asynchrones. Votre gestionnaire d’exceptions peut récupérer des informations plus détaillées sur la cause de l’exception pour mieux comprendre l’échec et prendre les décisions appropriées.

La méthode RetrieveFeedAsync lève une exception si une connexion n’a pas pu être établie avec le serveur HTTP ou que l’objet Uri ne pointe pas vers un flux AtomPub ou RSS valide. L’exemple de code JavaScript utilise une fonction onError pour intercepter les exceptions et imprimer des informations plus détaillées sur l’exception si une erreur se produit.

try
{
    // Although most HTTP servers do not require User-Agent header, 
    // others will reject the request or return a different response if this header is missing.
    // Use the setRequestHeader() method to add custom headers.
    client.SetRequestHeader("User-Agent", "Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; WOW64; Trident/6.0)");
    feed = await client.RetrieveFeedAsync(uri);
    // Retrieve the title of the feed and store it in a string.
    string title = feed.Title.Text;
    // Iterate through each feed item.
    foreach (Windows.Web.Syndication.SyndicationItem item in feed.Items)
    {
        displayCurrentItem(item);
    }
}
catch (Exception ex)
{
    // Handle the exception here.
}

function onError(err) {
    WinJS.log && WinJS.log(err, "sample", "error");
    // Match error number with an ErrorStatus value.
    // Use Windows.Web.WebErrorStatus.getStatus() to retrieve HTTP error status codes.
    var errorStatus = Windows.Web.Syndication.SyndicationError.getStatus(err.number);
    if (errorStatus === Windows.Web.Syndication.SyndicationErrorStatus.invalidXml) {
        displayLog("An invalid XML exception was thrown. Please make sure to use a URI that points to a RSS or Atom feed.");
    }
}
// Retrieve and display feed at given feed address.
function retreiveFeed(uri) {
    // Although most HTTP servers do not require User-Agent header, 
    // others will reject the request or return a different response if this header is missing.
    // Use the setRequestHeader() method to add custom headers.
    client.setRequestHeader("User-Agent", "Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; WOW64; Trident/6.0)");
    client.retrieveFeedAsync(uri).done(function (feed) {
        currentFeed = feed;
        WinJS.log && WinJS.log("Feed download complete.", "sample", "status");
        var title = "(no title)";
        if (currentFeed.title) {
            title = currentFeed.title.text;
        }
        document.getElementById("CurrentFeedTitle").innerText = title;
        currentItemIndex = 0;
        if (currentFeed.items.size > 0) {
            displayCurrentItem();
        }
        // List the items.
        displayLog("Items: " + currentFeed.items.size);
     }, onError);
}

À l’étape précédente, RetrieveFeedAsync a retourné le contenu du flux demandé et l’exemple de code doit fonctionner en itération via les éléments de flux disponibles. Chacun de ces éléments est représenté à l’aide d’un objet SyndicationItem qui contient toutes les propriétés et le contenu de l’élément offerts par la norme de syndication appropriée (RSS ou Atom). Dans l’exemple suivant, nous observons la fonction displayCurrentItem qui fonctionne à travers chaque élément et affiche son contenu via différents éléments d’interface utilisateur nommés.

private void displayCurrentItem(Windows.Web.Syndication.SyndicationItem item)
{
    string itemTitle = item.Title == null ? "No title" : item.Title.Text;
    string itemLink = item.Links == null ? "No link" : item.Links.FirstOrDefault().ToString();
    string itemContent = item.Content == null ? "No content" : item.Content.Text;
    //displayCurrentItem is continued below.

function displayCurrentItem() {
    var item = currentFeed.items[currentItemIndex];
    // Display item number.
    document.getElementById("Index").innerText = (currentItemIndex + 1) + " of " + currentFeed.items.size;
    // Display title.
    var title = "(no title)";
    if (item.title) {
        title = item.title.text;
    }
    document.getElementById("ItemTitle").innerText = title;
    // Display the main link.
    var link = "";
    if (item.links.size > 0) {
        link = item.links[0].uri.absoluteUri;
    }
    var linkElement = document.getElementById("Link");
    linkElement.innerText = link;
    linkElement.href = link;
    // Display the body as HTML.
    var content = "(no content)";
    if (item.content) {
        content = item.content.text;
    }
    else if (item.summary) {
        content = item.summary.text;
    }
    document.getElementById("WebView").innerHTML = window.toStaticHTML(content);
                //displayCurrentItem is continued below.

Comme indiqué précédemment, le type de contenu représenté par un objet SyndicationItem diffère selon la norme de flux (RSS ou Atom) utilisée pour publier le flux. Par exemple, un flux Atom est capable de fournir une liste de contributeurs, mais pas un flux RSS. Toutefois, les éléments d’extension inclus dans un élément de flux qui ne sont pas pris en charge par les éléments standard (par exemple, les éléments d’extension Dublin Core) sont accessibles à l’aide de la propriété SyndicationItem.ElementExtensions, puis affichés comme illustré dans l’exemple de code suivant.

    //displayCurrentItem continued.
    string extensions = "";
    foreach (Windows.Web.Syndication.SyndicationNode node in item.ElementExtensions)
    {
        string nodeName = node.NodeName;
        string nodeNamespace = node.NodeNamespace;
        string nodeValue = node.NodeValue;
        extensions += nodeName + "\n" + nodeNamespace + "\n" + nodeValue + "\n";
    }
    this.listView.Items.Add(itemTitle + "\n" + itemLink + "\n" + itemContent + "\n" + extensions);
}

    // displayCurrentItem function continued.
    var bindableNodes = [];
    for (var i = 0; i < item.elementExtensions.size; i++) {
        var bindableNode = {
            nodeName: item.elementExtensions[i].nodeName,
             nodeNamespace: item.elementExtensions[i].nodeNamespace,
             nodeValue: item.elementExtensions[i].nodeValue,
        };
        bindableNodes.push(bindableNode);
    }
    var dataList = new WinJS.Binding.List(bindableNodes);
    var listView = document.getElementById("extensionsListView").winControl;
    WinJS.UI.setOptions(listView, {
        itemDataSource: dataList.dataSource
    });
}