Feeds RSS/Atom

APIs importantes

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

Recuperar ou criar o conteúdo da Web mais atual e popular usando feeds distribuídos gerados de acordo com os padrões RSS e Atom com os recursos do namespace Windows.Web.Syndication.

O que é um feed?

Um feed da Web é um documento que contém qualquer número de entradas individuais compostas por texto, links e imagens. As atualizações feitas em um feed estão na forma de novas entradas usadas para promover o conteúdo mais recente na Web. Os consumidores de conteúdo podem usar um aplicativo de leitor de feed para agregar e monitorar feeds de qualquer número de autores de conteúdo individuais, obtendo acesso ao conteúdo mais recente de forma rápida e conveniente.

Quais padrões de formato de feed têm suporte?

O Windows oferece suporte à recuperação de feeds para os padrões de formato RSS de 0.91 a RSS 2.0 e para os padrões Atom de 0.3 a 1.0. As classes no namespace 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 documentos do feed contenham elementos ou atributos não definidos nas especificações oficiais. Com o tempo, esses elementos e atributos personalizados tornaram-se uma maneira de definir informações específicas do domínio consumidas por outros formatos de dados do serviço Web, como GData e OData. Para dar suporte a esse recurso adicionado, a classe SyndicationNode representa elementos XML genéricos. O uso de SyndicationNode com classes do namespace Windows.Data.Xml.Dom permite que os aplicativos acessem atributos, extensões e qualquer conteúdo que elas possam conter.

Observe que, para a publicação de conteúdo sindicado, a implementação do Windows do Atom Publication Protocol (Windows.Web.AtomPub) oferece suporte apenas a operações de conteúdo de feed de acordo com os padrões Atom e Atom Publication.

Usando conteúdo distribuído com isolamento de rede

O recurso de isolamento de rede em Windows permite que um desenvolvedor controle e limite o acesso à rede por um aplicativo Windows. Nem todos os aplicativos podem exigir acesso à rede. No entanto, para os aplicativos que fazem isso, Windows fornece diferentes níveis de acesso à rede que podem ser habilitados selecionando os recursos apropriados.

O isolamento de rede permite que um desenvolvedor defina para cada aplicativo o escopo do acesso à rede necessário. Um aplicativo sem o escopo apropriado definido é impedido de acessar o tipo de rede especificado e o tipo específico de solicitação de rede (solicitações iniciadas pelo cliente de saída ou solicitações não solicitadas de entrada e solicitações iniciadas pelo cliente de saída). A capacidade de definir e impor o isolamento de rede garante que, se um aplicativo for comprometido, ele só poderá acessar redes em que o aplicativo recebeu acesso explicitamente. Isso reduz significativamente o escopo do impacto em outros aplicativos e em Windows.

O isolamento de rede afeta quaisquer elementos de classe nos namespaces Windows.Web.Syndication e Windows.Web.AtomPub que tentem acessar a rede. Windows impõe ativamente o isolamento de rede. Uma chamada para um elemento de classe no namespace Windows.Web.Syndication ou Windows.Web.AtomPub que resulte em acesso à rede pode falhar devido ao isolamento de rede se a capacidade de rede apropriada não tiver sido habilitada.

Os recursos de rede de um aplicativo são configurados no manifesto do aplicativo quando o aplicativo é criado. Os recursos de rede geralmente são adicionados usando Visual Studio ao desenvolver o aplicativo. Os recursos de rede também podem ser definidos manualmente no arquivo de manifesto do aplicativo usando um editor de texto.

Para obter informações mais detalhadas sobre isolamento de rede e recursos de rede, consulte a seção "Recursos" no tópico Noções básicas de rede.

Como acessar um feed da Web

Esta seção mostra como recuperar e exibir um feed da Web usando classes no Windows. Namespace Web.Syndication em seu aplicativo Windows escrito em C#.

Pré-requisitos

Para garantir que seu aplicativo Windows esteja pronto para a rede, você deve definir todos os recursos de rede necessários no arquivo project Package.appxmanifest. Se seu aplicativo precisar se conectar como um cliente a serviços remotos na Internet, a funcionalidade internetClient será necessária. Para obter mais informações, consulte a seção "Funcionalidades" no tópico básico de rede .

Obtendo conteúdo sindicado de um feed da web

Agora, examinaremos alguns códigos que demonstram como recuperar um feed e exibir cada item individual que o feed contém. Antes de configurar e enviar a solicitação, definiremos algumas variáveis que usaremos durante a operação e inicializaremos uma instância do SyndicationClient, que define os métodos e as propriedades que usaremos para recuperar e exibir o feed.

O construtor Uri gera uma exceção se o uriString passado para o construtor não for um URI válido. Portanto, validamos o uriString usando um bloco 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;
}

Em seguida, configuramos a solicitação definindo as credenciais do servidor (a propriedade ServerCredential ), as credenciais de proxy (a propriedade ProxyCredential ) e os cabeçalhos HTTP (o método SetRequestHeader ) necessários. Com os parâmetros básicos de solicitação configurados, um objeto Uri válido, criado usando uma cadeia de caracteres de URI de feed fornecida pelo aplicativo. Em seguida, o objeto Uri é passado para a função RetrieveFeedAsync para solicitar o feed.

Supondo que o conteúdo do feed desejado tenha sido retornado, o código de exemplo itera por meio de cada item de feed, chamando displayCurrentItem (que definimos em seguida), para exibir itens e seu conteúdo como uma lista por meio da interface do usuário.

Você deve escrever código para lidar com exceções quando chamar a maioria dos métodos de rede assíncronos. Seu manipulador de exceção pode recuperar informações mais detalhadas sobre a causa da exceção para entender melhor a falha e tomar as decisões apropriadas.

O método RetrieveFeedAsync gera uma exceção se uma conexão não puder ser estabelecida com o servidor HTTP ou o objeto Uri não apontar para um atomPub ou RSS feed válido. O código de exemplo javaScript usa uma função onError para capturar quaisquer exceções e imprimir informações mais detalhadas sobre a exceção se ocorrer 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);
}

Na etapa anterior, RetrieveFeedAsync retornou o conteúdo do feed solicitado e o código de exemplo começou a funcionar iterando por meio de itens de feed disponíveis. Cada um desses itens é representado usando um objeto SyndicationItem que contém todas as propriedades do item e o conteúdo fornecidos pelo padrão de sindicalização relevante (RSS ou Atom). No exemplo a seguir, observamos a função displayCurrentItem trabalhando em cada item e exibindo seu conteúdo por meio de vários elementos de interface do usuário nomeados.

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.

Conforme sugerido anteriormente, o tipo de conteúdo representado por um objeto SyndicationItem será diferente dependendo do padrão de feed (RSS ou Atom) empregado para publicar o feed. Por exemplo, um feed Atom é capaz de fornecer uma lista de Colaboradores, mas um feed RSS não é. No entanto, os elementos de extensão incluídos em um item de feed que não são compatíveis com nenhum dos elementos de extensão padrão (por exemplo, elementos de extensão dublin core) podem ser acessados usando a propriedade SyndicationItem.ElementExtensions e, em seguida, exibidos como demonstrado no código de exemplo a seguir.

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