RSS/Atom-feeds

Belangrijke API's

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

Haal de meest recente en populaire webinhoud op met behulp van gesyndiceerde feeds die zijn gegenereerd volgens de RSS- en Atom-standaarden met behulp van functies in de Windows. Naamruimte Web.Syndication.

Wat is een feed?

Een webfeed is een document dat een willekeurig aantal afzonderlijke vermeldingen bevat die bestaan uit tekst, koppelingen en afbeeldingen. Updates die zijn aangebracht in een feed, hebben de vorm van nieuwe vermeldingen die worden gebruikt om de nieuwste inhoud op internet te promoten. Gebruikers van inhoud kunnen een feedlezer-app gebruiken om feeds van een willekeurig aantal afzonderlijke inhoudsauteurs samen te voegen en te controleren, zodat ze snel en gemakkelijk toegang krijgen tot de nieuwste inhoud.

Welke feedindelingsstandaarden worden ondersteund?

Windows ondersteunt het ophalen van feeds voor RSS-indelingsstandaarden van 0.91 tot RSS 2.0 en Atom-standaarden van 0.3 tot 1.0. Klassen in de Windows. Web.Syndication-naamruimte kan feeds en feeditems definiëren die zowel RSS- als Atom-elementen kunnen vertegenwoordigen.

Daarnaast staan de formaten Atom 1.0 en RSS 2.0 beide toe dat hun feeddocumenten elementen of attributen bevatten die niet in de officiële specificaties zijn gedefinieerd. In de loop van de tijd zijn deze aangepaste elementen en kenmerken een manier geworden om domeinspecifieke informatie te definiëren die wordt gebruikt door andere webservicegegevensindelingen, zoals GData en OData. Ter ondersteuning van deze toegevoegde functie vertegenwoordigt de klasse SyndicationNode algemene XML-elementen. SyndicationNode gebruiken met klassen in de Windows. Data.Xml.Dom-naamruimte, biedt apps toegang tot kenmerken, extensies en inhoud die ze kunnen bevatten.

Houd er rekening mee dat voor de publicatie van syndicated inhoud de Windows implementatie van het Atom Publication Protocol (Windows). Web.AtomPub) ondersteunt alleen feedinhoudsbewerkingen volgens de atom- en Atom-publicatiestandaarden.

Gesyndiceerde inhoud gebruiken met netwerkisolatie

Met de functie netwerkisolatie in Windows kan een ontwikkelaar de netwerktoegang beheren en beperken door een Windows-app. Niet alle apps hebben mogelijk toegang tot het netwerk nodig. Voor apps die dit doen, biedt Windows echter verschillende toegangsniveaus tot het netwerk die kunnen worden ingeschakeld door de juiste mogelijkheden te selecteren.

Met netwerkisolatie kan een ontwikkelaar voor elke app het bereik van de vereiste netwerktoegang definiëren. Een app zonder het juiste bereik dat is gedefinieerd, kan geen toegang krijgen tot het opgegeven type netwerk en een specifiek type netwerkaanvraag (door de client geïnitieerde uitgaande aanvragen of zowel binnenkomende ongevraagde aanvragen als door de client geïnitieerde aanvragen). De mogelijkheid om netwerkisolatie in te stellen en af te dwingen, zorgt ervoor dat als een app wordt gecompromitteerd, alleen toegang heeft tot netwerken waarvoor de app expliciet toegang heeft gekregen. Dit vermindert het bereik van de impact op andere toepassingen en op Windows aanzienlijk.

Netwerkisolatie is van invloed op alle klasse-elementen in de Windows. Web.Syndication en Windows. Web.AtomPub-naamruimten die toegang proberen te krijgen tot het netwerk. Windows dwingt actief netwerkisolatie af. Een aanroep naar een klasse-element in de Windows. Web.Syndication of Windows. Web.AtomPub-naamruimte die resulteert in netwerktoegang kan mislukken vanwege netwerkisolatie als de juiste netwerkmogelijkheid niet is ingeschakeld.

De netwerkmogelijkheden voor een app worden geconfigureerd in het app-manifest wanneer de app wordt gebouwd. Netwerkmogelijkheden worden meestal toegevoegd met behulp van Visual Studio bij het ontwikkelen van de app. Netwerkmogelijkheden kunnen ook handmatig worden ingesteld in het manifestbestand van de app met behulp van een teksteditor.

Zie de sectie Mogelijkheden in het onderwerp Basisbeginselen van netwerken voor meer gedetailleerde informatie over netwerkisolatie en netwerkmogelijkheden.

Toegang krijgen tot een webfeed

In deze sectie ziet u hoe u een webfeed ophaalt en weergeeft met behulp van klassen in de Windows. Web.Syndication-naamruimte in uw Windows-app die is geschreven in C#.

Vereisten

Om ervoor te zorgen dat uw Windows app gereed is voor het netwerk, moet u netwerkmogelijkheden instellen die nodig zijn in het project Package.appxmanifest-bestand. Als uw app als client verbinding moet maken met externe services op internet, is de mogelijkheid internetClient nodig. Zie de sectie Mogelijkheden in het onderwerp Basisbeginselen van netwerken voor meer informatie.

Gesyndiceerde inhoud ophalen uit een webfeed

Nu gaan we enkele code bekijken die laat zien hoe u een feed ophaalt en vervolgens elk afzonderlijk item weergeeft dat de feed bevat. Voordat we de aanvraag kunnen configureren en verzenden, definiëren we een paar variabelen die we tijdens de bewerking gaan gebruiken en initialiseren we een exemplaar van SyndicationClient, waarmee de methoden en eigenschappen worden gedefinieerd die we gebruiken om de feed op te halen en weer te geven.

De URI-constructor genereert een uitzondering als de uriString die wordt doorgegeven aan de constructor geen geldige URI is. We valideren dus de uriString met behulp van een try/catch-blok.

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

Vervolgens configureren we de aanvraag door serverreferenties (de eigenschap ServerCredential ), proxyreferenties (de eigenschap ProxyCredential ) en HTTP-headers (de methode SetRequestHeader ) in te stellen die nodig zijn. Wanneer de basisaanvraagparameters zijn geconfigureerd, een geldig URI-object , gemaakt met behulp van een feed-URI-tekenreeks die door de app wordt geleverd. Het URI-object wordt vervolgens doorgegeven aan de functie RetrieveFeedAsync om de feed aan te vragen.

Ervan uitgaande dat de gewenste feedinhoud is geretourneerd, doorloopt de voorbeeldcode elk feeditem, waarbij displayCurrentItem (die we hierna definiëren) wordt aangeroepen om items en hun inhoud weer te geven als een lijst via de gebruikersinterface.

U moet code schrijven om uitzonderingen af te handelen wanneer u de meeste asynchrone netwerkmethoden aanroept. Uw uitzonderingshandler kan gedetailleerdere informatie over de oorzaak van de uitzondering ophalen om de fout beter te begrijpen en passende beslissingen te nemen.

De methode RetrieveFeedAsync genereert een uitzondering als er geen verbinding kan worden gemaakt met de HTTP-server of het URI-object verwijst niet naar een geldige AtomPub- of RSS-feed. De JavaScript-voorbeeldcode maakt gebruik van een onError-functie om eventuele uitzonderingen te ondervangen en gedetailleerdere informatie over de uitzondering af te drukken als er een fout optreedt.

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

In de vorige stap heeft RetrieveFeedAsync de aangevraagde feedinhoud geretourneerd en is de voorbeeldcode doorlopen via beschikbare feeditems. Elk van deze items wordt weergegeven met behulp van een SyndicationItem-object dat alle itemeigenschappen en inhoud bevat die wordt geboden door de relevante syndicatiestandaard (RSS of Atom). In het volgende voorbeeld zien we dat de functie displayCurrentItem door elk item werkt en de inhoud ervan weergeeft via verschillende benoemde UI-elementen.

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.

Zoals eerder is voorgesteld, verschilt het type inhoud dat wordt vertegenwoordigd door een SyndicationItem-object , afhankelijk van de feedstandaard (RSS of Atom) die wordt gebruikt om de feed te publiceren. Een Atom-feed kan bijvoorbeeld een lijst met inzenders leveren, maar een RSS-feed is dat niet. Uitbreidingselementen die zijn opgenomen in een feeditem die niet worden ondersteund door een van beide standaardelementen (bijvoorbeeld Dublin Core-extensie-elementen) kunnen echter worden geopend met behulp van de eigenschap SyndicationItem.ElementExtensions en vervolgens worden weergegeven zoals wordt weergegeven in de volgende voorbeeldcode.

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