WhenAny: Überbrückung zwischen .NET Framework und Windows-Runtime (C# und Visual Basic)

Artikel
03/12/2013

Das Beispiel in diesem Thema Windows-Runtime kombiniert einen Typ, der Blogfeeds asynchron mit einer .NET Framework-Methode herunterladen, die asynchrone Aufgaben in der Reihenfolge verarbeitet, in der sie ausführen.Weitere Informationen zum - Typ, finden Sie unter SyndicationClient.Weitere Informationen über die - Methode, finden Sie unter Task.WhenAny.

Mit dieser Funktionen kombinieren, können Sie starten, um mehrere Blogfeeds gleichzeitig herunterzuladen und die Ergebnisse zu verarbeiten, während sie abgeschlossen sind.Wenn ein Feedback schneller als die anderen herunterladen, werden die Ergebnisse zuerst.Wenn Sie eine SyndicationClient-Methode verwenden, können Sie die Feeds leicht herunterladen; Task.WhenAny mithilfe der - Methode verwenden, den folgenden Feedback problemlos identifizieren, der Herunterladen abgeschlossen ist.

Hinweis
Um das Beispiel auszuführen, müssen Sie Windows 8 enthalten, das auf dem Computer installiert ist.Wenn Sie das Beispiel aus Visual Studio ausführen möchten, müssen Sie Visual Studio 2012 auch oder Visual Studio Express 2012 für Windows 8 installiert.

Der folgende Code kombiniert diese Funktionen von Windows-Runtime und von .NET Framework:

SyndicationClient.RetrieveFeedAsync lädt die Blogfeeds herunter und gibt IAsyncOperationWithProgress-Instanzen zurück.
Die AsTask erweiterungsmethode stellt die IAsyncOperationWithProgress-Instanzen als Task<TResult>-Instanzen dar.
WhenAny gibt eine Aufgabe zurück, die die erste Aufgabe in einer Auflistung Aufgaben aufgewendet identifiziert.

Try
    Dim feedsQuery As IEnumerable(Of Task(Of SyndicationFeed)) =
        From uri In uriList
        Select client.RetrieveFeedAsync(uri).AsTask()
    ' AsTask changes the returns from RetrieveFeedAsync into tasks.

    ' Run the query to start all the asynchronous processes.
    Dim blogFeedTasksList As List(Of Task(Of SyndicationFeed)) = feedsQuery.ToList()

    Dim feed As SyndicationFeed

    ' Repeat the following until there are no tasks left:
    '    - Grab the first one that finishes.
    '    - Retrieve the results from the task (what the return statement 
    '      in RetrieveFeedAsync returns).
    '    - Remove the task from the list.
    '    - Display the results.
    While blogFeedTasksList.Count > 0
        Dim nextTask As Task(Of SyndicationFeed) = Await Task.WhenAny(blogFeedTasksList)
        feed = Await nextTask
        blogFeedTasksList.Remove(nextTask)
        DisplayResults(feed)
    End While

Catch ex As Exception
    ResultsTextBox.Text =
        "Page could not be loaded." & vbCrLf & "Exception: " & ex.ToString()
End Try

try
{
    IEnumerable<Task<SyndicationFeed>> feedsQuery =
            from uri in uriList
            // AsTask changes the returns from RetrieveFeedAsync into tasks.
            select client.RetrieveFeedAsync(uri).AsTask();

    // Run the query to start all the asynchronous processes.
    List<Task<SyndicationFeed>> blogFeedTasksList = feedsQuery.ToList();

    SyndicationFeed feed;

    // Repeat the following until no tasks remain:
    //    - Grab the first one that finishes.
    //    - Retrieve the results from the task (what the return statement 
    //      in RetrieveFeedAsync returns).
    //    - Remove the task from the list.
    //    - Display the results.
    while (blogFeedTasksList.Count > 0)
    {
        Task<SyndicationFeed> nextTask = await Task.WhenAny(blogFeedTasksList);
        feed = await nextTask;                    
        blogFeedTasksList.Remove(nextTask);
        DisplayResults(feed);
    }
}
catch (Exception ex)
{
    ResultsTextBox.Text =
        "Page could not be loaded.\n\r" + "Exception: " + ex.ToString();
}

Das Beispiel erzeugt Ausgabe, die den folgenden Zeilen ähnelt.Für jedes Blog zeigt die Anzeige den Titel des Blogs an, das bis zu den Namen und den Datumsangaben für Blogbeiträge folgen.

Developing for Windows
     New blog for Windows 8 app developers, 5/1/2012 2:33:02 PM -07:00
     Trigger-Start Services Recipe, 3/24/2011 2:23:01 PM -07:00
     . . .
     Countdown to PDC10, 10/26/2010 4:11:28 PM -07:00

Extreme Windows Blog
     PDXLAN 20: “Epidemic” Custom PC by Jon Hansz, 7/30/2012 2:31:35 PM -07:00
     Samsung Notebook Series 9: Taking Thin and Light to the Extreme, 7/23/2012 12:06:03 PM -07:00
     . . .
     AMD Unveils A-Series APUs, 6/13/2011 9:34:01 PM -07:00

Blogging Windows
     Windows 8 has reached the RTM milestone, 8/1/2012 9:00:00 AM -07:00
     Windows 8 will be available on…, 7/18/2012 1:09:00 PM -07:00
     . . .
     More buzz from BUILD – Developers get their devices!, 9/13/2011 7:47:57 PM -07:00

Springboard Series Blog
     What to Expect in User Experience Virtualization Beta 2, 6/25/2012 11:03:27 PM -07:00
     Introducing Microsoft BitLocker Administration 2.0 Beta, 6/12/2012 8:08:23 AM -07:00
     . . .
     The Springboard Series Visits Lima, Peru, 11/18/2011 5:27:37 AM -08:00

Der Rest dieses Themas stellt Informationen darüber, wie Sie das Beispiel erstellen und wie sie funktioniert.

Sie müssen Visual Studio 2012 und Windows 8 verfügen, die auf dem Computer installiert sein, um diese App auszuführen.

Dieses Thema enthält folgende Abschnitte.

Setup-Optionen für das Beispiel
Kenntnisse des Startcodes
Erweitern des Startcodes
Herunterladen des Startcodes
Herunterladen der fertigen App
Erstellen des Startcodes
Erstellen der fertigen App
Verwandte Themen

Setup-Optionen für das Beispiel

Das Beispiel basiert auf den Blogreader, der unter Schnellstart: mithilfe des Erwartungsoperators für asynchrone Programmierung beschrieben wird.jedoch lädt der Startcode für dieses Thema mehrere Blogfeeds statt nur einem herunter.

Der Startcode verwendet Windows-Runtime-Funktionen, um die Blogfeeds sequenziell herunterzuladen.Das heißt, dass die Blogfeeds in der Reihenfolge heruntergeladen, in der sie in einer Auflistung URL aufgeführt sind.Die fertige App werden Funktionen von .NET Framework hinzu, um die Blogfeeds in herunterzuladen die Reihenfolge, in der sie ausführen.

Sie können den Beispielcode in einer der folgenden Methoden installieren:

Startcode.
- Sie können den Startcode herunterladen, indem Sie die Anweisungen in Herunterladen des Startcodes entsprechen,
- Sie können den Startcode selbst erstellen, indem Sie die Anweisungen in Erstellen des Startcodes befolgen.
- Sie können den Startcode überprüfen, ohne sie durch zu implementieren, indem Sie Erstellen des Startcodes zu wechseln.
Fertige App.
- Sie können die fertige App herunterladen, indem Sie die Anweisungen in Herunterladen der fertigen App befolgen
- Sie können die Anwendung selbst erstellen, indem Sie die Anweisungen in Erstellen der fertigen App befolgen.
- Sie können die fertige App überprüfen, ohne sie zu implementieren, indem Sie Erstellen der fertigen App zu wechseln.

Der Kenntnisse des Startcodes-Abschnitt erläutert Punkte in der Basislösung.

Der Erweitern des Startcodes-Abschnitt wird erläutert, wie der Code geändert, indem er AsTask und Task.WhenAny hinzugefügt wird.

Kenntnisse des Startcodes

Der Startcode verwendet eine SyndicationClient-Methode RetrieveFeedAsync, um einen Blogfeed von einem URI in einer Liste von URIs herunterzuladen.Jeder Aufruf der - Methode gibt eine IAsyncOperationWithProgress-Instanz zurück, die einen laufenden asynchronen Operation darstellt.Wenn er erwartet wird, erzeugt die asynchrone Operation eine SyndicationFeed-Instanz, die Informationen über den heruntergeladenen Blogfeed enthält.

Der Code definiert eine Abfrage, die RetrieveFeedAsync zu jedem Eintrag in einer Liste von URIs angewendet wird.Wenn sie ausgeführt wird, gibt die Abfrage eine Auflistung IAsyncOperationWithProgress-Instanzen zurück.

Dim feedsQuery As IEnumerable(Of IAsyncOperationWithProgress(Of SyndicationFeed, 
                                                                RetrievalProgress)) =
                                                From uri In uriList
                                                Select client.RetrieveFeedAsync(uri)

IEnumerable<IAsyncOperationWithProgress<SyndicationFeed, 
    RetrievalProgress>> feedsQuery = from uri in uriList
                                     select client.RetrieveFeedAsync(uri);

ToList<TSource> führt die Abfrage aus und beginnt die asynchronen Prozesse, wie im folgenden Code veranschaulicht.

Dim blogFeedOpsList As List(Of IAsyncOperationWithProgress(Of SyndicationFeed, 
                                                           RetrievalProgress)) =
                                               feedsQuery.ToList()

List<IAsyncOperationWithProgress<SyndicationFeed, 
    RetrievalProgress>> blogFeedOpsList = feedsQuery.ToList();

Sie haben jetzt eine Liste aktiver IAsyncOperationWithProgress-Instanzen.Sie müssen jede Instanz noch erwarten, dass die Endergebnisse abzurufen.

Die folgende - Schleife erwartet IAsyncOperationWithProgress jede Instanz, um die SyndicationFeed Ergebnisse abzurufen.

Dim feed As SyndicationFeed
For Each blogFeedOp In blogFeedOpsList
    ' The Await operator retrieves the final result (a SyndicationFeed instance)
    ' from each IAsyncOperation instance.
    feed = Await blogFeedOp
    DisplayResults(feed)
Next

SyndicationFeed feed;
foreach (var blogFeedOp in blogFeedOpsList)
{
    // The await operator retrieves the final result (a SyndicationFeed instance)
    // from each IAsyncOperation instance.
    feed = await blogFeedOp;
    DisplayResults(feed);
}

Sie können diese Version des Programms im Building the Starter Code-Abschnitt am Ende des Themas überprüfen.

Sie können weitere Informationen zum Programmieren mit asynchronem Windows-Runtime API suchen in Schnellstart: mithilfe des Erwartungsoperators für asynchrone Programmierung.

Erweitern des Startcodes

Der Startcode zeigt, dass SyndicationClient es einfach, Blogfeeds Microsoft-Webplattform problemlos.Im restlichen Schritt, um das Beispiel auszuführen ist, die Anwendung zu ermöglichen, die Blogfeeds in zu verarbeiten die Reihenfolge, in der die Downloads vollständig anstelle der Reihenfolge, in der sie in der Liste der URI angezeigt werden.

Der Schlüssel zum das der Erweiterung ist die Task.WhenAny-Methode.Wenn Sie WhenAny zu einer Auflistung asynchronen Prozesse anwenden, gibt die Methode den ersten Prozess, der Abschluss zurück und reduziert die Zeit, die Sie warten müssen.In diesem Beispiel ist die Reihenfolge, in der die Blogfeedinformationen angezeigt werden, nicht wichtig.Wenn ein Download langsam, können die Ergebnisse von einem anderen Blog zuerst anzeigen.Die Situation scheint für WhenAny mit Ausnahme einer Ursache perfekt: WhenAny erfordert eine Auflistung Aufgaben.

Aufrufen von AsTask

WhenAny erfordert eine Auflistung Task oder Task<TResult>-Instanzen, die SyndicationClient-Methode, die das Blog herunterladen, speist gibt eine IAsyncOperationWithProgress-Instanz.Daher muss die Anwendung zwischen den IAsyncOperationWithProgress-Objekten aus Windows-Runtime und Task-Objekten von .NET Framework überbrücken.

. .NET Framework stellt AsTask erweiterungsmethoden, um den Übergang zu machen.Wenn Sie AsTask auf einer Instanz IAsyncOperationWithProgress aufrufen, gibt AsTask eine Aufgabe zurück, die den asynchronen Vorgang darstellt.Die Aufgabe schließt ab, wenn die entsprechende IAsyncOperationWithProgress-Instanz abgeschlossen wurde, und die Aufgabe hat das Ergebnis der oder die Ausnahme Instanz.

Daher rufen Sie nur AsTask auf jeder Instanz IAsyncOperationWithProgress auf, die RetrieveFeedAsync zurückgibt, als der folgende Code angezeigt wird.Der Code wird die Variablen, um die Änderung an Aufgaben zu reflektieren und verwendet explizites aus Gründen der Übersichtlichkeit eingeben.

Dim feedsQuery As IEnumerable(Of Task(Of SyndicationFeed)) =
    From uri In uriList
    Select client.RetrieveFeedAsync(uri).AsTask()
' AsTask changes the returns from RetrieveFeedAsync into tasks.

' Run the query to start all the asynchronous processes.
Dim blogFeedTasksList As List(Of Task(Of SyndicationFeed)) = feedsQuery.ToList()

IEnumerable<Task<SyndicationFeed>> feedsQuery =
        from uri in uriList
        // AsTask changes the returns from RetrieveFeedAsync into tasks.
        select client.RetrieveFeedAsync(uri).AsTask();

// Run the query to start all the asynchronous processes.
List<Task<SyndicationFeed>> blogFeedTasksList = feedsQuery.ToList();

Hinweis
AsTask gibt eine wichtige Rolle in der asynchronen Programmierung erneut, die Sie wahrscheinlich nicht bewusst sind.Der Compiler verwendet AsTask, wenn ein Erwartungsoperator zu einer IAsyncAction oder IAsyncOperation-Instanz anwenden, wie im folgenden Code veranschaulicht. `' What you write. Dim feed As SyndicationFeed = Await client.RetrieveFeedAsync(feedUri) ' What the compiler does. ' Dim feed As SyndicationFeed = Await client.RetrieveFeedAsync(feedUri).AsTask()` `// What you write. SyndicationFeed feed = await client.RetrieveFeedAsync(feedUri); // What the compiler does. //SyndicationFeed feed = await client.RetrieveFeedAsync(feedUri).AsTask();`

Hinweis

AsTask gibt eine wichtige Rolle in der asynchronen Programmierung erneut, die Sie wahrscheinlich nicht bewusst sind.Der Compiler verwendet AsTask, wenn ein Erwartungsoperator zu einer IAsyncAction oder IAsyncOperation-Instanz anwenden, wie im folgenden Code veranschaulicht.

' What you write.
Dim feed As SyndicationFeed = Await client.RetrieveFeedAsync(feedUri)

' What the compiler does.
' Dim feed As SyndicationFeed = Await client.RetrieveFeedAsync(feedUri).AsTask()

// What you write.     
SyndicationFeed feed = await client.RetrieveFeedAsync(feedUri); 

// What the compiler does.  
//SyndicationFeed feed = await client.RetrieveFeedAsync(feedUri).AsTask();

Anwenden von WhenAny

Der letzte Schritt in der Konvertierung ist, die Task.WhenAny-Methode der App hinzuzufügen.WhenAny wird zu einer Auflistung Aufgaben (blogFeedTasksList) und gibt die erste Aufgabe in der Auflistung angewendet, die abgeschlossen hat.Außerdem gibt WhenAny eine Aufgabe zurück, die, wenn sie erwartet wird, Aufgabe ergibt, die zuerst beendet wurde.

Die folgende - Anweisung ruft WhenAny auf und das Ergebnis erwartet.Der Code verwendet die explizite Typisierung, um das Ergebnis eindeutig anzuzeigen.

Dim nextTask As Task(Of SyndicationFeed) = Await Task.WhenAny(blogFeedTasksList)

Task<SyndicationFeed> nextTask = await Task.WhenAny(blogFeedTasksList);

Im folgenden Code wird die gleiche Aufgabe wie die vorherige Anweisung jedoch die Timeouts der Vorgang in zwei Anweisungen, um zu erläutern, was geschieht.Die erste Anweisung ruft WhenAny auf, und die zweite Anweisung erwartet das Ergebnis.

' WhenAny returns a task that, when awaited, produces a task.
' Call:
Dim whenAnyTask As Task(Of Task(Of SyndicationFeed)) = Task.WhenAny(blogFeedTasksList)
' Await:
Dim nextTask As Task(Of SyndicationFeed) = Await whenAnyTask

// WhenAny returns a task that, when awaited, produces a task.
// Call:
Task<Task<SyndicationFeed>> whenAnyTask = Task.WhenAny(blogFeedTasksList);
// Await:
Task<SyndicationFeed> nextTask = await whenAnyTask;

Abschließend müssen Sie nextTask erwarten, dass die Ergebnisse (eine Instanz SyndicationFeed ) von der Aufgabe abzurufen, die zuerst beendet wurde, und müssen Sie nextTask aus der Liste entfernen, damit Sie sie nicht erneut verarbeiten.

feed = Await nextTask
blogFeedTasksList.Remove(nextTask)

feed = await nextTask;                    
blogFeedTasksList.Remove(nextTask);

Verwenden Sie eine While-Schleife, um diese Schritte für jede Aufgabe in blogFeedTasksList auszuführen.

While blogFeedTasksList.Count > 0
    Dim nextTask As Task(Of SyndicationFeed) = Await Task.WhenAny(blogFeedTasksList)
    feed = Await nextTask
    blogFeedTasksList.Remove(nextTask)
    DisplayResults(feed)
End While

while (blogFeedTasksList.Count > 0)
{
    Task<SyndicationFeed> nextTask = await Task.WhenAny(blogFeedTasksList);
    feed = await nextTask;                    
    blogFeedTasksList.Remove(nextTask);
    DisplayResults(feed);
}

Sie können diese Version des Programms im Erstellen der fertigen App-Abschnitt am Ende des Themas überprüfen.Oder Sie können die Anweisungen in Herunterladen der fertigen App entsprechen, das Projekt herunterzuladen.

Vorsicht
Die Verwendung von WhenAny in einer Schleife, wie im Beispiel beschrieben, ist zwar für Probleme, die eine kleine Anzahl Aufgaben einschließen.sind jedoch andere Ansätze effizienter, wenn viele Aufgaben verarbeitet haben.Weitere Informationen und Beispiele finden Sie unter Verarbeiten von Aufgaben, wie sie ausführen.

Herunterladen des Startcodes

Sie können den Startcode für das Beispiel von Asynchrones Beispiel: Überbrückung zwischen von .NET zu Windows herunterladen.Wenn Sie keinen Zugriff auf den Internet haben, befolgen Sie die Anweisungen in Erstellen des Startcodes am Ende dieses Themas, den Startcode zu erstellen.

Nachdem Sie den Code herunterladen, öffnen Sie und führen diesen aus, indem Sie die folgenden Schritte ausführen.

Dekomprimieren Sie die Datei, die Sie heruntergeladen haben, und starten Sie dann Visual Studio 2012.
Klicken Sie in der Menüleiste auf Datei, dann auf Öffnen und Projekt/Projektmappe.
Navigieren Sie zum Ordner, der den dekomprimierten Beispielcode enthält, und öffnen Sie die Projektmappendatei (.sln) für AsTaskWhenAnyDemoVB oder AsTaskWhenAnyDemoCS.
In Projektmappen-Explorer öffnen Sie das Kontextmenü für das SequentialBlogReader Projekt, und wählen Sie dann Als Startprojekt festlegen aus.
Wählen Sie die F5-TASTE, um das Projekt zu erstellen und auszuführen.
Führen Sie den Code mehrmals aus, zu überprüfen, dass die Ergebnisse in der gleichen Reihenfolge jedes Mal angezeigt werden.

Sie können die MainPage.xaml.vb- oder MainPage.xaml.cs-Datei im Erstellen des Startcodes-Abschnitt am Ende des Themas überprüfen.

Informationen über zahlreiche Verbesserungen und Erweiterungen, die Sie der Anwendung ausführen können, finden Sie unter Erstellen Sie einen Blogreader erstellt.

Herunterladen der fertigen App

Wenn Sie nicht das Beispiel selbst erstellen möchten, können Sie das vollständige Beispiel herunterladen.Befolgen Sie die Anweisungen im Abschnitt Herunterladen des Startcodes, wählen Sie jedoch WhenAnyBlogReader als Startprojekt aus.

Führen Sie das Programm mehrmals ausgeführt werden, zu überprüfen, dass die Blogfeeds in verschiedenen Aufträge angezeigt werden.

Sie können die MainPage.xaml.vb- oder MainPage.xaml.cs-Datei im Erstellen der fertigen App-Abschnitt am Ende des Themas überprüfen.

Erstellen des Startcodes

Sie können die Beispiele in diesem Thema von Asynchrones Beispiel: Überbrückung zwischen von .NET zu Windows herunterladen.Wenn Sie es vorziehen, die Anwendung in selbst festzulegen, führen Sie folgende Schritte aus.

Starten Sie Visual Studio 2012.
Wählen Sie in der Menüleiste Datei, Neu, Projekt aus.

Das Dialogfeld Neues Projekt wird angezeigt.
In Installiert wählen Kategorie Vorlagen, Visual Basic oder Visual C# aus und wählen dann Windows Store in der Liste der - Projekttypen aus.
In der Liste der - Projekttypen, wählen Sie Leere App (XAML) aus.
Nennen Sie das Projekt SequentialBlogReader, und wählen Sie dann die Schaltfläche OK aus.

Das neue Projekt wird im Projektmappen-Explorer angezeigt.
In Projektmappen-Explorer öffnen Sie das Kontextmenü für "MainPage.xaml", und wählen Sie dann Öffnen aus.

Im Fenster XAML von "MainPage.xaml", ersetzen Sie den Code durch den folgenden Code.

<Page
    x:Class="SequentialBlogReader.MainPage"
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:AsTaskWhenAnyDemo"
    xmlns:d="https://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="https://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d">

    <Grid Background="{StaticResource ApplicationPageBackgroundThemeBrush}">
        <Button x:Name="StartButton" Content="Start" HorizontalAlignment="Stretch" Margin="325,128,330,0" VerticalAlignment="Top" Click="StartButton_Click" Height="71" Background="#FFA89B9B" FontWeight="Bold" FontSize="36"/>
        <TextBox x:Name="ResultsTextBox" Margin="325,222,330,0" TextWrapping="Wrap" VerticalAlignment="Top" Height="546" FontSize="10" ScrollViewer.VerticalScrollBarVisibility="Visible" />
    </Grid>
</Page>

Ein einfaches Fenster, das ein Textfeld und eine Schaltfläche enthält, wird im Fenster Entwurf von " MainPage.xaml ".

Informationen über zahlreiche Verbesserungen und Erweiterungen, die Sie dem Benutzeroberfläche ausführen können, finden Sie unter Erstellen Sie einen Blogreader erstellt.

In Projektmappen-Explorer öffnen Sie das Kontextmenü für MainPage.xaml.vb oder MainPage.xaml.cs, und wählen Sie dann Code anzeigen aus.

Ersetzen Sie den Code in MainPage.xaml.vb oder in MainPage.xaml.cs durch den folgenden Code.

' Add an Imports statement for SyndicationClient.
Imports Windows.Web.Syndication


' The Blank Page item template is documented at http:'go.microsoft.com/fwlink/?LinkId=234238

Public NotInheritable Class MainPage
    Inherits Page

    Protected Overrides Sub OnNavigatedTo(e As Navigation.NavigationEventArgs)

    End Sub


    ' The async modifier enables you to use await in the event handler.
    Private Async Sub StartButton_Click(sender As Object, e As RoutedEventArgs)
        ResultsTextBox.Text = ""

        ' Disable the button until the operation is complete.
        StartButton.IsEnabled = False

        Dim client As Windows.Web.Syndication.SyndicationClient = New SyndicationClient()

        ' Force the SyndicationClient to download the information.
        client.BypassCacheOnRetrieve = True

        Dim uriList = CreateUriList()

        Try
            Dim feedsQuery As IEnumerable(Of IAsyncOperationWithProgress(Of SyndicationFeed, 
                                                                            RetrievalProgress)) =
                                                            From uri In uriList
                                                            Select client.RetrieveFeedAsync(uri)

            ' Run the query to start all the asynchronous processes.
            Dim blogFeedOpsList As List(Of IAsyncOperationWithProgress(Of SyndicationFeed, 
                                                                       RetrievalProgress)) =
                                                           feedsQuery.ToList()

            Dim feed As SyndicationFeed
            For Each blogFeedOp In blogFeedOpsList
                ' The Await operator retrieves the final result (a SyndicationFeed instance)
                ' from each IAsyncOperation instance.
                feed = Await blogFeedOp
                DisplayResults(feed)
            Next

        Catch ex As Exception
            ResultsTextBox.Text =
                "Page could not be loaded." & vbCrLf & "Exception: " & ex.ToString()
        End Try

        ' Reenable the button in case you want to run the operation again.
        StartButton.IsEnabled = True
    End Sub


    Function CreateUriList() As List(Of Uri)

        ' Create a list of URIs.
        Dim uriList = New List(Of Uri) From
        {
                New Uri("https://windowsteamblog.com/windows/b/developers/atom.aspx"),
                New Uri("https://windowsteamblog.com/windows/b/extremewindows/atom.aspx"),
                New Uri("https://windowsteamblog.com/windows/b/bloggingwindows/atom.aspx"),
                New Uri("https://windowsteamblog.com/windows/b/springboard/atom.aspx")
        }
        Return uriList
    End Function


    Sub DisplayResults(sf As SyndicationFeed)

        ' Title of the blog.
        ResultsTextBox.Text &= sf.Title.Text & vbCrLf

        ' Titles and dates for blog posts.
        For Each item As SyndicationItem In sf.Items

            ResultsTextBox.Text &= vbTab & item.Title.Text & ", " &
                                item.PublishedDate.ToString() & vbCrLf
        Next

        ResultsTextBox.Text &= vbCrLf
    End Sub
End Class

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Windows.Foundation;
using Windows.Foundation.Collections;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Controls.Primitives;
using Windows.UI.Xaml.Data;
using Windows.UI.Xaml.Input;
using Windows.UI.Xaml.Media;
using Windows.UI.Xaml.Navigation;

// Add a using directive for SyndicationClient.
using Windows.Web.Syndication;


namespace SequentialBlogReader
{
    public sealed partial class MainPage : Page
    {
        public MainPage()
        {
            this.InitializeComponent();
        }

        protected override void OnNavigatedTo(NavigationEventArgs e)
        {
        }


        private async void StartButton_Click(object sender, RoutedEventArgs e)
        {
            ResultsTextBox.Text = "";

            // Disable the button until the operation is complete.
            StartButton.IsEnabled = false;

            Windows.Web.Syndication.SyndicationClient client = new SyndicationClient();

            // Force the SyndicationClient to download the information.
            client.BypassCacheOnRetrieve = true;

            var uriList = CreateUriList();

            try
            {
                IEnumerable<IAsyncOperationWithProgress<SyndicationFeed, 
                    RetrievalProgress>> feedsQuery = from uri in uriList
                                                     select client.RetrieveFeedAsync(uri);

                // Run the query to start all the asynchronous processes.
                List<IAsyncOperationWithProgress<SyndicationFeed, 
                    RetrievalProgress>> blogFeedOpsList = feedsQuery.ToList();

                SyndicationFeed feed;
                foreach (var blogFeedOp in blogFeedOpsList)
                {
                    // The await operator retrieves the final result (a SyndicationFeed instance)
                    // from each IAsyncOperation instance.
                    feed = await blogFeedOp;
                    DisplayResults(feed);
                }
            }
            catch (Exception ex)
            {
                ResultsTextBox.Text =
                    "Page could not be loaded.\n\r" + "Exception: " + ex.ToString();
            }

            // Reenable the button in case you want to run the operation again.
            StartButton.IsEnabled = true;
        }

        List<Uri> CreateUriList()
        {
            // Create a list of URIs.
            List<Uri> uriList = new List<Uri> 
            { 
                new Uri("https://windowsteamblog.com/windows/b/developers/atom.aspx"),
                new Uri("https://windowsteamblog.com/windows/b/extremewindows/atom.aspx"),
                new Uri("https://windowsteamblog.com/windows/b/bloggingwindows/atom.aspx"),
                new Uri("https://windowsteamblog.com/windows/b/springboard/atom.aspx")
            };
            return uriList;
        }


        void DisplayResults(SyndicationFeed sf)
        {
            // Title of the blog.
            ResultsTextBox.Text += sf.Title.Text + "\r\n";

            // Titles and dates for blog posts.
            foreach (SyndicationItem item in sf.Items)
            {
                ResultsTextBox.Text += "\t" + item.Title.Text + ", " +
                                    item.PublishedDate.ToString() + "\r\n";
            }
            ResultsTextBox.Text += "\r\n";
        }
    }
}

Wählen Sie die F5-TASTE, um das Programm auszuführen, und wählen Sie dann die Schaltfläche Start aus.

Erstellen der fertigen App

Starten Sie Visual Studio 2012.
Wählen Sie in der Menüleiste Datei, Neu, Projekt aus.

Das Dialogfeld Neues Projekt wird angezeigt.
In Installiert wählen Kategorie Vorlagen, Visual Basic oder Visual C# aus und wählen dann Windows Store aus.
Ziehen Sie aus der Liste der - Projekttypen, wählen Sie Leere App (XAML) aus.
Nennen Sie das Projekt WhenAnyBlogReader, und wählen Sie dann die Schaltfläche OK aus.

Das neue Projekt wird im Projektmappen-Explorer angezeigt.
In Projektmappen-Explorer öffnen Sie das Kontextmenü für "MainPage.xaml", und wählen Sie dann Öffnen aus.