Feed RSS/Atom

API Importanti

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

Recupera o crea i contenuti Web più recenti e popolari mediante feed distribuiti generati in base agli standard RSS e Atom usando le funzionalità nello spazio dei nomi Windows.Web.Syndication.

Che cos'è un feed?

Un feed Web è un documento che contiene un numero qualsiasi di singole voci costituite da testo, collegamenti e immagini. Gli aggiornamenti apportati a un feed sono sotto forma di nuove voci usate per promuovere il contenuto più recente sul Web. I consumer di contenuti possono usare un'app lettore di feed per aggregare e monitorare i feed di un numero qualsiasi di singoli autori di contenuti, ottenendo l'accesso al contenuto più recente in modo rapido e pratico.

Quali standard di formato di feed sono supportati?

Windows supporta il recupero dei feed per gli standard di formato RSS da 0.91 a RSS 2.0 e standard Atom da 0.3 a 1.0. Le classi nello spazio dei nomi Windows.Web.Syndication possono definire feed ed elementi dei feed in grado di rappresentare sia elementi RSS che Atom.

Inoltre, i formati Atom 1.0 e RSS 2.0 consentono ai documenti di feed di contenere elementi o attributi non definiti nelle specifiche ufficiali. Nel corso del tempo, questi elementi e attributi personalizzati sono diventati un modo per definire informazioni specifiche del dominio utilizzate da altri formati di dati del servizio Web, ad esempio GData e OData. Per supportare questa funzionalità aggiunta, la classe SyndicationNode rappresenta elementi XML generici. L'uso di SyndicationNode con le classi nello spazio dei nomi Windows.Data.Xml.Dom consente alle app di accedere ad attributi, estensioni e a qualsiasi contenuto possano contenere.

Si noti che, per la pubblicazione di contenuto diffuso, l'implementazione Windows del protocollo di pubblicazione Atom (Windows. Web.AtomPub) supporta solo le operazioni sul contenuto del feed in base agli standard Atom e Atom Publication.

Uso di contenuto distribuito con isolamento di rete

La funzionalità di isolamento della rete in Windows consente a uno sviluppatore di controllare e limitare l'accesso alla rete da parte di un'app Windows. Non tutte le app potrebbero richiedere l'accesso alla rete. Tuttavia, per le app che lo fanno, Windows fornisce diversi livelli di accesso alla rete che possono essere abilitati selezionando le funzionalità appropriate.

L'isolamento della rete consente a uno sviluppatore di definire per ogni app l'ambito dell'accesso di rete necessario. A un'app senza l'ambito appropriato definito viene impedito di accedere al tipo di rete specificato e al tipo specifico di richiesta di rete indicato (richieste in uscita avviate dal client oppure sia richieste in ingresso non sollecitate sia richieste in uscita avviate dal client). La possibilità di impostare e applicare l'isolamento della rete garantisce che, se un'app viene compromessa, può accedere solo alle reti in cui l'app ha concesso in modo esplicito l'accesso. In questo modo si riduce significativamente l'ambito dell'impatto su altre applicazioni e sulle Windows.

L'isolamento della rete influisce su qualsiasi elemento di classe negli spazi dei nomi Windows.Web.Syndication e Windows.Web.AtomPub che tenta di accedere alla rete. Windows applica attivamente l'isolamento di rete. Una chiamata a un elemento di classe nello spazio dei nomi Windows.Web.Syndication o Windows.Web.AtomPub che comporta l'accesso alla rete potrebbe non andare a buon fine a causa dell'isolamento di rete se la funzionalità di rete appropriata non è stata abilitata.

Le funzionalità di rete per un'app vengono configurate nel manifesto dell'app al momento della compilazione dell'app. Le funzionalità di rete vengono in genere aggiunte usando Visual Studio durante lo sviluppo dell'app. Le funzionalità di rete possono anche essere impostate manualmente nel file manifesto dell'app usando un editor di testo.

Per informazioni più dettagliate sull'isolamento della rete e sulle funzionalità di rete, vedere la sezione "Funzionalità" nell'argomento Nozioni di base sulla rete .

Come accedere a un feed web

Questa sezione illustra come recuperare e visualizzare un feed web usando le classi nello spazio dei nomi Windows.Web.Syndication in un'app Windows scritta in C#.

Requisiti

Per assicurarsi che l'app Windows sia pronta per la rete, è necessario impostare tutte le funzionalità di rete necessarie nel file Package.appxmanifest del progetto. Se l'app deve connettersi come client a servizi remoti su Internet, è necessaria la funzionalità internetClient . Per altre informazioni, vedere la sezione "Funzionalità" nell'argomento Nozioni di base sulla rete .

Recupero di contenuto diffuso da un feed Web

Verranno ora esaminati alcuni codici che illustrano come recuperare un feed e quindi visualizzare ogni singolo elemento contenuto nel feed. Prima di poter configurare e inviare la richiesta, verranno definite alcune variabili che verranno usate durante l'operazione e inizializzare un'istanza di SyndicationClient, che definisce i metodi e le proprietà che verranno usati per recuperare e visualizzare il feed.

Il costruttore URI genera un'eccezione se l'uriString passato al costruttore non è un URI valido. Viene quindi convalidato l'uriString usando un blocco 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;
}

Configurare quindi la richiesta impostando le credenziali del server (la proprietà ServerCredential ), le credenziali proxy (la proprietà ProxyCredential ) e le intestazioni HTTP (il metodo SetRequestHeader ) necessarie. Con i parametri di richiesta di base configurati, un oggetto Uri valido, creato usando una stringa di URI del feed fornita dall'app. L'oggetto Uri viene quindi passato alla funzione RetrieveFeedAsync per richiedere il feed.

Supponendo che il contenuto del feed desiderato sia stato restituito, il codice di esempio scorre ogni elemento del feed, chiamando displayCurrentItem (definito successivamente), per visualizzare gli elementi e il relativo contenuto come elenco tramite l'interfaccia utente.

È necessario scrivere codice per gestire le eccezioni quando si chiamano la maggior parte dei metodi di rete asincroni. Il gestore eccezioni può recuperare informazioni più dettagliate sulla causa dell'eccezione per comprendere meglio l'errore e prendere decisioni appropriate.

Il metodo RetrieveFeedAsync genera un'eccezione se non è stato possibile stabilire una connessione con il server HTTP o l'oggetto Uri non punta a un feed AtomPub o RSS valido. Il codice di esempio JavaScript usa una funzione onError per intercettare eventuali eccezioni e stampare informazioni più dettagliate sull'eccezione in caso di errore.

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

Nel passaggio precedente, RetrieveFeedAsync ha restituito il contenuto del feed richiesto e il codice di esempio ha iniziato a iterare tra gli elementi del feed disponibili. Ognuno di questi elementi viene rappresentato usando un oggetto SyndicationItem che contiene tutte le proprietà e il contenuto dell'elemento offerti dallo standard di diffusione pertinente (RSS o Atom). Nell'esempio seguente si osserva la funzione displayCurrentItem che usa ogni elemento e ne visualizza il contenuto tramite vari elementi denominati dell'interfaccia utente.

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.

Come suggerito in precedenza, il tipo di contenuto rappresentato da un oggetto SyndicationItem varia a seconda dello standard del feed (RSS o Atom) usato per pubblicare il feed. Ad esempio, un feed Atom è in grado di fornire un elenco di collaboratori, ma un feed RSS non è. Tuttavia, è possibile accedere agli elementi di estensione inclusi in un elemento del feed che non sono supportati da entrambi gli elementi standard (ad esempio, gli elementi dell'estensione Dublin Core) usando la proprietà SyndicationItem.ElementExtensions e quindi visualizzati come illustrato nel codice di esempio seguente.

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