Fuentes RSS y Atom

API importantes

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

Recuperar o crear el contenido de la Web más actual y popular mediante fuentes sindicadas generadas según los estándares RSS y Atom usando las características del espacio de nombres Windows.Web.Syndication.

¿Qué es una fuente?

Una fuente web es un documento que contiene cualquier número de entradas individuales formadas por texto, vínculos e imágenes. Las actualizaciones realizadas en un canal se presentan en forma de nuevas entradas que se utilizan para difundir el contenido más reciente en la Web. Los consumidores de contenido pueden usar una aplicación de lector de fuentes para agregar y supervisar fuentes de cualquier número de autores de contenido individuales, obteniendo acceso al contenido más reciente de forma rápida y cómoda.

¿Qué estándares de formato de fuente se admiten?

Windows admite la recuperación de fuentes para estándares de formato RSS de 0.91 a RSS 2.0 y estándares Atom de 0.3 a 1.0. Las clases del espacio de nombres Windows.Web.Syndication pueden definir canales y elementos de canal capaces de representar elementos RSS y Atom.

Además, los formatos Atom 1.0 y RSS 2.0 permiten que sus documentos de fuente contengan elementos o atributos no definidos en las especificaciones oficiales. Con el tiempo, estos atributos y elementos personalizados se han convertido en una manera de definir información específica del dominio consumida por otros formatos de datos de servicio web, como GData y OData. Para admitir esta característica agregada, la clase SyndicationNode representa elementos XML genéricos. El uso de SyndicationNode con clases del espacio de nombres Windows.Data.Xml.Dom permite a las aplicaciones acceder a atributos, extensiones y a cualquier contenido que estos puedan contener.

Tenga en cuenta que, para la publicación de contenido sindicado, la implementación de Windows del Protocolo de publicación Atom (Windows.Web.AtomPub) solo admite operaciones de contenido de canal de acuerdo con los estándares Atom y Atom Publication.

Uso de contenido sindicado con aislamiento de red

La característica de aislamiento de red de Windows permite al desarrollador controlar y limitar el acceso a la red mediante una aplicación de Windows. No todas las aplicaciones pueden requerir acceso a la red. Sin embargo, para las aplicaciones que lo hacen, Windows proporciona distintos niveles de acceso a la red que se pueden habilitar seleccionando las funcionalidades adecuadas.

El aislamiento de red permite a un desarrollador definir para cada aplicación el ámbito de acceso de red necesario. Se impide que una aplicación sin el ámbito adecuado definido acceda al tipo de red especificado y a un tipo específico de solicitud de red (solicitudes iniciadas por el cliente saliente o tanto solicitudes entrantes no solicitadas como solicitudes iniciadas por el cliente saliente). La capacidad de establecer y aplicar el aislamiento de red garantiza que si una aplicación se pone en peligro, solo puede acceder a las redes a las que se le ha concedido acceso explícitamente. Esto reduce significativamente el ámbito del impacto en otras aplicaciones y en Windows.

El aislamiento de red afecta a cualquier elemento de clase de los espacios de nombres Windows.Web.Syndication y Windows.Web.AtomPub que intenten acceder a la red. Windows aplica activamente el aislamiento de red. Una llamada a un elemento de clase del espacio de nombres Windows.Web.Syndication o Windows.Web.AtomPub que dé lugar al acceso a la red puede fallar debido al aislamiento de red si no se ha habilitado la capacidad de red adecuada.

Las funcionalidades de red de una aplicación se configuran en el manifiesto de la aplicación cuando se compila la aplicación. Las funcionalidades de red normalmente se agregan mediante Visual Studio al desarrollar la aplicación. Las funcionalidades de red también se pueden establecer manualmente en el archivo de manifiesto de la aplicación mediante un editor de texto.

Para obtener información más detallada sobre el aislamiento de red y las funcionalidades de red, consulte la sección "Funcionalidades" del tema Conceptos básicos de redes .

Cómo acceder a una fuente web

En esta sección se muestra cómo recuperar y mostrar una fuente web utilizando clases del espacio de nombres Windows.Web.Syndication en tu aplicación de Windows escrita en C#.

Requisitos previos

Para asegurarse de que la aplicación de Windows esté lista para la red, debe establecer las funcionalidades de red necesarias en el archivo Package.appxmanifest del proyecto. Si la aplicación necesita conectarse como cliente a servicios remotos en Internet, se necesita la funcionalidad InternetClient . Para obtener más información, vea la sección "Funcionalidades" del tema Conceptos básicos de redes .

Recuperación de contenido sindicado desde una fuente web

Ahora revisaremos algún código que muestre cómo recuperar una fuente y, a continuación, mostraremos cada elemento individual que contiene la fuente. Para poder configurar y enviar la solicitud, definiremos algunas variables que usaremos durante la operación e inicializaremos una instancia de SyndicationClient, que define los métodos y propiedades que usaremos para recuperar y mostrar la fuente.

El constructor URI produce una excepción si el uriString pasado al constructor no es un URI válido. Por lo tanto, validamos uriString mediante un bloque 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;
}

A continuación, se configura la solicitud estableciendo las credenciales del servidor (la propiedad ServerCredential ), las credenciales de proxy (la propiedad ProxyCredential ) y los encabezados HTTP (el método SetRequestHeader ) necesarios. Con los parámetros de solicitud básicos configurados, un objeto URI válido, creado mediante una cadena de URI de fuente proporcionada por la aplicación. A continuación, el objeto Uri se pasa a la función RetrieveFeedAsync para solicitar la fuente.

Suponiendo que se devolvió el contenido de fuente deseado, el código de ejemplo recorre en iteración cada elemento de fuente, llamando a displayCurrentItem (que definimos a continuación), para mostrar los elementos y su contenido como una lista a través de la interfaz de usuario.

Debe escribir código para controlar las excepciones cuando llame a la mayoría de los métodos de red asincrónicos. El controlador de excepciones puede recuperar información más detallada sobre la causa de la excepción para comprender mejor el error y tomar las decisiones adecuadas.

El método RetrieveFeedAsync produce una excepción si no se pudo establecer una conexión con el servidor HTTP o el objeto URI no apunta a una fuente AtomPub o RSS válida. El código de ejemplo de JavaScript usa una función onError para detectar las excepciones e imprimir información más detallada sobre la excepción si se produce un error.

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

En el paso anterior, RetrieveFeedAsync devolvió el contenido de fuente solicitado y el código de ejemplo tuvo que recorrer en iteración los elementos de fuente disponibles. Cada uno de estos elementos se representa mediante un objeto SyndicationItem que contiene todas las propiedades del elemento y el contenido que ofrece el estándar de distribución pertinente (RSS o Atom). En el ejemplo siguiente observamos que la función displayCurrentItem funciona a través de cada elemento y muestra su contenido a través de varios elementos de interfaz de usuario con nombre.

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 se sugirió anteriormente, el tipo de contenido representado por un objeto SyndicationItem variará en función del estándar de fuente (RSS o Atom) empleado para publicar la fuente. Por ejemplo, una fuente Atom es capaz de proporcionar una lista de colaboradores, pero no es una fuente RSS. Sin embargo, se puede acceder a los elementos de extensión incluidos en un elemento de fuente que no son compatibles con ninguno de los elementos de extensión estándar (por ejemplo, elementos de extensión Dublín Core) mediante la propiedad SyndicationItem.ElementExtensions y, a continuación, se muestra como se muestra en el código de ejemplo siguiente.

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