Feeds RSS/Atom

APIs importantes

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

Obter ou criar o conteúdo da Web mais atual e popular utilizando feeds sindicados gerados de acordo com as normas RSS e Atom, através das funcionalidades do espaço de nomes Windows.Web.Syndication.

O que é um feed?

Um feed web é um documento que contém qualquer número de entradas individuais compostas por texto, links e imagens. As atualizações feitas num feed são sob a forma de novas entradas usadas para promover o conteúdo mais recente na Web. Os consumidores de conteúdo podem usar uma aplicação leitora de feeds para agregar e monitorizar feeds de qualquer número de autores individuais, obtendo acesso ao conteúdo mais recente de forma rápida e conveniente.

Que padrões de formatos de feed são suportados?

O Windows suporta a recuperação de feeds para padrões de formato RSS desde 0.91 até RSS 2.0, e para padrões Atom de 0.3 a 1.0. As classes no espaço de nomes Windows.Web.Syndication podem definir feeds e itens de feed capazes de representar elementos RSS e Atom.

Além disso, os formatos Atom 1.0 e RSS 2.0 permitem que os seus documentos de alimentação contenham elementos ou atributos não definidos nas especificações oficiais. Com o tempo, estes elementos e atributos personalizados tornaram-se uma forma de definir informação específica de domínio consumida por outros formatos de dados de serviços web como GData e OData. Para suportar esta funcionalidade adicional, a classe SyndicationNode representa elementos XML genéricos. Usar SyndicationNode com classes no espaço de nomes Windows.Data.Xml.Dom permite às aplicações aceder a atributos, extensões e a qualquer conteúdo neles contido.

Note-se que, para a publicação de conteúdos sindicados, a implementação do Windows do Atom Publication Protocol (Windows. Web.AtomPub) apenas suporta operações de conteúdo de feed de acordo com os padrões Atom e Atom Publication.

Utilização de conteúdo sindicado com isolamento de rede

A funcionalidade de isolamento de rede no Windows permite ao programador controlar e limitar o acesso à rede por uma aplicação Windows. Nem todas as aplicações podem exigir acesso à rede. No entanto, para as aplicações que o fazem, o Windows oferece diferentes níveis de acesso à rede que podem ser ativados selecionando as capacidades apropriadas.

O isolamento de rede permite a um programador definir para cada aplicação o âmbito do acesso à rede necessário. Uma aplicação sem o âmbito apropriado definido é impedida de aceder ao tipo de rede especificado e ao tipo específico de pedido de rede (pedidos de saída iniciados pelo cliente ou tanto pedidos não solicitados de entrada como de saída iniciados pelo cliente). A capacidade de definir e impor isolamento de rede garante que, se uma aplicação for comprometida, só pode aceder a redes onde a aplicação tenha sido explicitamente concedida. Isto reduz significativamente o impacto noutras aplicações e no Windows.

O isolamento de rede afeta quaisquer elementos de classe no Windows. Web.Syndication e Windows. Web.AtomPub que tentam aceder à rede. O Windows impõe ativamente o isolamento da rede. Uma chamada a um elemento de classe no espaço de nomes Windows.Web.Syndication ou Windows.Web.AtomPub que resulte em acesso à rede pode falhar devido ao isolamento de rede se a capacidade de rede adequada não tiver sido ativada.

As capacidades de rede de uma aplicação são configuradas no manifesto da aplicação quando a aplicação é construída. As capacidades de rede são normalmente adicionadas usando o Visual Studio durante o desenvolvimento da aplicação. As capacidades de rede também podem ser definidas manualmente no ficheiro manifesto da aplicação usando um editor de texto.

Para informações mais detalhadas sobre isolamento de rede e capacidades de rede, consulte a secção "Capacidades" no tópico Fundamentos de Redes .

Como aceder a um feed da Web

Esta secção mostra como recuperar e apresentar um feed da Web usando classes no espaço de nomes Windows.Web.Syndication na sua aplicação Windows escrita em C#.

Pré-requisitos

Para garantir que a sua aplicação Windows está pronta para a rede, deve definir todas as capacidades de rede necessárias no ficheiro Package.appxmanifest do projeto. Se a sua aplicação precisa de se ligar como cliente a serviços remotos na Internet, então é necessária a capacidade internetClient . Para mais informações, consulte a secção "Capacidades" no tópico Fundamentos de Redes .

Recuperar conteúdo sindicado de um feed web

Agora vamos rever algum código que demonstra como recuperar um feed e depois mostrar cada item individual que o feed contém. Antes de podermos configurar e enviar o pedido, definiremos algumas variáveis que iremos usar durante a operação e inicializaremos uma instância do SyndicationClient, que define os métodos e propriedades que usaremos para recuperar e mostrar o feed.

O construtor Uri lança uma exceção se o uriString passado ao construtor não for um URI válido. Por isso, validamos o uriString usando um bloqueio 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;
}

De seguida, configuramos o pedido definindo quaisquer credenciais de servidor (a propriedade ServerCredential ), credenciais proxy (propriedade ProxyCredential ) e cabeçalhos HTTP (método SetRequestHeader ) necessários. Com os parâmetros básicos de pedido configurados, um objeto Uri válido, criado usando uma cadeia de URI de alimentação fornecida pela aplicação. O objeto Uri é então passado para a função RetrieveFeedAsync para solicitar o feed.

Assumindo que o conteúdo desejado do feed foi devolvido, o código de exemplo itera por cada item do feed, chamando displayCurrentItem (que definimos a seguir), para mostrar os itens e o seu conteúdo como uma lista através da interface.

Deve escrever código para lidar com exceções ao chamar a maioria dos métodos assíncronos de rede. O seu gestor de exceções pode obter informações mais detalhadas sobre a causa da exceção para compreender melhor a falha e tomar decisões apropriadas.

O método RetrieveFeedAsync lança uma exceção se não puder ser estabelecida uma ligação com o servidor HTTP ou se o objeto Uri não apontar para um feed válido em AtomPub ou RSS. O código de exemplo JavaScript utiliza uma função onError para detetar quaisquer exceções e imprimir informações mais detalhadas sobre a exceção caso ocorra um erro.

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);
}

No passo anterior, o RetrieveFeedAsync devolveu o conteúdo do feed solicitado e o código de exemplo começou a iterar pelos itens disponíveis do feed. Cada um destes itens é representado através de um objeto SyndicationItem que contém todas as propriedades e conteúdos do item fornecidos pelo padrão de sindicância relevante (RSS ou Atom). No exemplo seguinte, observamos a função displayCurrentItem a trabalhar em cada item e a exibir o seu conteúdo através de vários elementos nomeados da interface.

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.

Como sugerido anteriormente, o tipo de conteúdo representado por um objeto SyndicationItem variará consoante o padrão de feed (RSS ou Atom) utilizado para publicar o feed. Por exemplo, um feed Atom é capaz de fornecer uma lista de Contributores, mas um feed RSS não o é. No entanto, elementos de extensão incluídos num item de alimentação que não são suportados por nenhum dos padrões (por exemplo, elementos de extensão Dublin Core) podem ser acedidos usando a propriedade SyndicationItem.ElementExtensions e depois exibidos, como demonstrado no seguinte código de exemplo.

    //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
    });
}