Feed RSS/Atom
API importanti
Recuperare o creare il contenuto Web più recente e diffusi usando feed pubblici 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?
La piattaforma UWP (Universal Windows Platform) 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 di feed in grado di rappresentare sia gli 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 classi nello spazio dei nomi Windows.Data.Xml.Dom consente alle app di accedere a attributi, estensioni e contenuto che possono contenere.
Si noti che, per la pubblicazione di contenuto pubblicato, l'implementazione UWP del protocollo Atom Publication Protocol (Windows.Web.AtomPub) supporta solo le operazioni sul contenuto del feed in base agli standard Atom e Atom Publication.
Uso del contenuto diffuso con isolamento di rete
La funzionalità di isolamento della rete nella piattaforma UWP consente a uno sviluppatore di controllare e limitare l'accesso alla rete tramite un'app UWP. Non tutte le app potrebbero richiedere l'accesso alla rete. Tuttavia, per queste app che eseguono questa operazione, la piattaforma UWP offre diversi livelli di accesso alla rete che possono essere abilitati selezionando le funzionalità appropriate.
L'isolamento della rete consente allo sviluppatore di definire per ogni app l'ambito dell'accesso di rete necessario. Un'app senza l'ambito appropriato definito non può accedere al tipo di rete specificato e a un tipo specifico di richiesta di rete (richieste avviate dal client in uscita o richieste non sollecitate in ingresso e richieste avviate dal client in uscita). La possibilità di impostare e applicare l'isolamento della rete garantisce che, se un'app viene compromessa, può accedere solo alle reti in relazione alle quali l'app ha concesso in modo esplicito l'accesso. In questo modo si riduce significativamente l'ambito dell'impatto su altre applicazioni e su Windows.
L'isolamento della rete influisce su qualsiasi elemento della classe negli spazi dei nomi Windows.Web.Syndication e Windows.Web.AtomPub che tentano di accedere alla rete. Windows applica attivamente l'isolamento di rete. Una chiamata a un elemento della classe nello spazio dei nomi Windows.Web.Syndication o Windows.Web.AtomPub che determina un errore di accesso alla rete a causa dell'isolamento della 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. Di solito, le funzionalità di rete vengono aggiunte tramite Microsoft Visual Studio 2015 quando si sviluppa l'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 classi nello spazio dei nomi Windows.Web.Syndication nell'app UWP scritta in C# o JavaScript.
Prerequisiti
Per assicurarsi che l'app UWP sia pronta per la rete, devi 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 su diversi canali 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’elemento uriString trasferito al costruttore non è un URI valido. Viene quindi convalidato l'elemento 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, creato usando una stringa 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, richiamando displayCurrentItem (definito successivamente), per visualizzare gli elementi e il relativo contenuto come elenco tramite l'interfaccia utente.
È necessario scrivere il codice per gestire le eccezioni quando si richiama 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 ottenuto l'iterazione degli 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 link = document.getElementById("Link");
link.innerText = link;
link.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 lo è. È tuttavia possibile accedere agli elementi di estensione inclusi in un elemento del feed che non sono supportati da nessuno dei due standard (ad esempio, gli elementi di estensione Dublin Core) usando la proprietà SyndicationItem.ElementExtensions. Tali elementi possono essere quindi visualizzati come dimostrato 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
});
}