WhenAny: łączenie platformy .NET Framework ze środowiskiem wykonawczym systemu Windows (C# i Visual Basic)

Artykuł
03/12/2013

Przykład w tym temacie łączy Środowisko wykonawcze systemu Windows typu, który pobiera blogu źródeł danych asynchronicznie za pomocą metody.NET Framework, która przetwarza zadań asynchronicznych w kolejności, w którym uzupełniają.Aby uzyskać więcej informacji o typie, zobacz SyndicationClient.Aby uzyskać więcej informacji na temat metody, zobacz Task.WhenAny.

Łącząc te funkcje, można uruchomić jednocześnie pobrać wiele kanałów blogu i przetworzenia wyników po ich zakończeniu.Jeśli jeden karmić szybciej niż pozostałe pliki do pobrania, jako pierwsze występują jego wyniki.Za pomocą SyndicationClient metody, można pobrać źródła danych, łatwiej; za pomocą Task.WhenAny metody, można łatwiej zidentyfikować dalej źródła danych, które zakończy się pobieranie.

[!UWAGA]

Aby uruchomić przykład, musi mieć 8 Windows zainstalowany na komputerze.Ponadto, jeśli chcesz uruchomić przykład z programu Visual Studio, trzeba mieć również Visual Studio 2012 lub programu Visual Studio Express 2012 dla Windows 8 zainstalowane.

Poniższy kod łączy te funkcje z Środowisko wykonawcze systemu Windows i .NET Framework:

SyndicationClient.RetrieveFeedAsync pliki do pobrania blog źródeł danych i zwraca IAsyncOperationWithProgress wystąpień.
AsTask Reprezentuje metoda rozszerzenia IAsyncOperationWithProgress wystąpień jako Task<TResult> wystąpień.
WhenAnyZwraca wartość określającą pierwsze zadanie w zbiorze zadań do wykonania zadania.

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

W przykładzie daje dane wyjściowe podobne do następujących wierszy.Dla każdego bloga na wyświetlaczu tytule blogu, a następnie tytuły i daty na blogach.

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

Pozostałej części tego tematu szczegółowe informacje na temat sposobów tworzenia w przykładzie i jak działa.

Musisz mieć Visual Studio 2012 i Windows 8 zainstalowanego programu do uruchomienia tej aplikacji.

Ten temat zawiera następujące sekcje.

Opcje instalacji dla przykładu
Opis kod startowy
Rozszerzanie kod startowy
Pobieranie kodu Starter
Pobieranie gotowych aplikacji
Kod startowy budynku
Budowanie gotowy aplikacji
Tematy pokrewne

Opcje instalacji dla przykładu

Przykład jest oparty na czytnik blogu, który jest opisany w Szybki Start: za pomocą operatora oczekiwać dla asynchronicznego programowania,.Jednak kod startowy dla tego tematu pliki do pobrania wiele kanałów blogu zamiast jednego.

Kod startowy używa Środowisko wykonawcze systemu Windows funkcjonalność, aby pobrać blog kanały sekwencyjnie.Oznacza to blog źródła danych są pobierane w kolejności, w którym są one wymienione w zbiór adresów URL.Gotowy aplikacji dodaje funkcje z .NET Framework Aby pobrać blog źródła w kolejności, w którym się uzupełniają.

Należy zdefiniować kod przykładowy w dowolnym z następujących sposobów:

Kod Starter.
- Możesz pobrać kod startowy zgodnie z instrukcjami w Pobieranie kodu Starter,
- Aby utworzyć kod startowy się zgodnie z instrukcjami zawartymi w Kod startowy budynku.
- Możesz przejrzeć kod startowy bez stosowania go przez przewijając widok do Kod startowy budynku.
Gotowy aplikacji.
- Możesz pobrać gotowy aplikacji zgodnie z instrukcjami wPobieranie gotowych aplikacji
- Można zbudować aplikację sobie zgodnie z instrukcjami w Budowanie gotowy aplikacji.
- Możesz przejrzeć gotowy aplikacji bez jego realizacji, przewijając widok do Budowanie gotowy aplikacji.

Opis kod startowy Sekcji omówiono podstawowe elementy podstawowe rozwiązanie.

Rozszerzanie kod startowy Sekcji przedstawiono sposób modyfikacji kodu przez dodanie AsTask i Task.WhenAny.

Opis kod startowy

Kod startowy używa SyndicationClient metodę, RetrieveFeedAsync, aby pobrać blogu pasz z każdego identyfikatora URI, na liście identyfikatorów URI.Zwraca każde wywołanie metody IAsyncOperationWithProgress instancji, która reprezentuje trwających operacji asynchronicznej.Gdy oczekiwany, operacja asynchroniczna produkuje SyndicationFeed wystąpienia, które zawiera informacje o pobranych kanał bloga.

Kod definiuje kwerendę, która stosuje się RetrieveFeedAsync do każdego wpisu na liście identyfikatorów URI.Podczas wykonywania kwerendy zwraca kolekcję IAsyncOperationWithProgress wystąpień.

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>wykonuje kwerendę i rozpoczyna proces asynchroniczny, co ilustruje poniższy kod.

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

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

W tym momencie użytkownik ma listę działających IAsyncOperationWithProgress wystąpień.Nadal musi czekać na każde wystąpienie na ostateczne wyniki.

Następujące pętli czeka na każdym IAsyncOperationWithProgress wystąpienie pobrać SyndicationFeed wyniki.

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

Możesz przejrzeć tej wersji programu w Building the Starter Code sekcji na końcu tematu.

Można znaleźć więcej informacji na temat programowania w języku asynchroniczne Środowisko wykonawcze systemu Windows API w Szybki Start: za pomocą operatora oczekiwać dla asynchronicznego programowania,.

Rozszerzanie kod startowy

Kod startowy wykaże, że SyndicationClient sprawia, że łatwo pobrać blogu źródła danych.Pozostały krok, aby dokończyć przykład jest umożliwienie stosowania do procesu, który blogu źródła danych w kolejności, w którym ich pobrania ukończyć a nie w kolejności, w jakiej występują na liście identyfikatorów URI.

Kluczem do osiągnięcia poprawy jest Task.WhenAny metoda.Po zastosowaniu WhenAny do kolekcji asynchronicznych procesów, metoda zwraca pierwszy proces, który uzupełnia, minimalizując czas, który musi czekać.W tym przykładzie kolejność, w którym są wyświetlane blogu podawanie informacji nie są ważne.Jeżeli jeden plik do pobrania jest powolne, najpierw wyświetlić wyniki z innego blogu.Sytuacja wydaje się idealny do WhenAny , z wyjątkiem jednej rzeczy: WhenAny wymaga zbiorem zadań.

Powołując się na AsTask

WhenAnywymaga to zbiór Task lub Task<TResult> wystąpienia, ale SyndicationClient metodę, która pobiera blogu kanały zwraca IAsyncOperationWithProgress wystąpienie.W związku z tym, aplikacja musi mostki między IAsyncOperationWithProgress obiekty z Środowisko wykonawcze systemu Windows i Task obiektów z.NET Framework.

.NET Framework zapewnia AsTask rozszerzenie metody przy przechodzeniu.Kiedy wywołać AsTask na IAsyncOperationWithProgress instancji, AsTask zwraca zadanie, które reprezentuje operacja asynchroniczna.Zadanie zostanie ukończone, gdy odpowiednie IAsyncOperationWithProgress kończy wystąpienie i zadanie ma wynik instancji lub wyjątek.

W związku z tym, po prostu uruchomić AsTask na każdym IAsyncOperationWithProgress instancji, że RetrieveFeedAsync zwraca wartość, co ilustruje poniższy kod.Kod zmienia nazwy zmiennych w celu odzwierciedlenia zmian do zadań i używa jawnych wpisywanie wartości jasności.

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

[!UWAGA]

AsTaskodgrywa ważną rolę w transmisji asynchronicznej programowania, że prawdopodobnie nie są świadomi.Kompilator używa AsTask razem z każdym zastosowanym operatorowi czekać na IAsyncAction lub IAsyncOperation instancji, co ilustruje poniższy kod.
' 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();

Zastosowanie WhenAny

Ostatnim krokiem w wyniku konwersji jest dodanie Task.WhenAny metoda do aplikacji.WhenAnyjest stosowany do kolekcji zadań (blogFeedTasksList) i zwraca pierwsze zadanie w kolekcji, w której jest wykonywane.W szczególności WhenAny zwraca zadanie, gdy oczekiwana, daje w wyniku zadania, który wygrał.

Następujące wywołania instrukcja WhenAny i czeka na wynik.W kodzie wykorzystano jawne wpisywanie, aby wyraźniej pokazać wynik.

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

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

Poniższy kod działa tak samo jak poprzednia, ale dzieli operację na dwie instrukcje wyjaśnienie, co się dzieje.Pierwszych zaproszeniach instrukcja WhenAny, a druga instrukcja czeka na wynik.

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

Wreszcie, musi czekać na nextTask do pobierania wyników ( SyndicationFeed wystąpienie) od zadania, które ukończyły po raz pierwszy, a następnie należy usunąć nextTask z listy tak, aby nie przetwarzają ją ponownie.

feed = Await nextTask
blogFeedTasksList.Remove(nextTask)

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

Użyj chwilę pętlę, aby wykonać te czynności dla każdego zadania w blogFeedTasksList.

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

Możesz przejrzeć tej wersji programu w Budowanie gotowy aplikacji sekcji na końcu tematu.Lub postępuj zgodnie z instrukcjami wyświetlanymi w Pobieranie gotowych aplikacji do pobrania projektu.

Przestroga
Użycie WhenAny w pętli, jak opisano w przykładzie, jest w porządku występują problemy, które mogą obejmować kilka zadań.Jednak inne podejścia są bardziej efektywne, jeśli masz dużą liczbę zadania do przetwarzania.Aby uzyskać dodatkowe informacje i przykłady, zobacz Przetwarzania zadań, jak one pełną.

Pobieranie kodu Starter

Można pobrać kod startowy, na przykład z próbki asynchroniczne: mostkowanie z .NET do systemu Windows.Jeśli nie masz dostępu do Internetu, postępuj zgodnie z instrukcjami wyświetlanymi w Kod startowy budynku na końcu tego tematu, aby utworzyć kod starter.

Po pobraniu kod należy otworzyć i uruchomić go, wykonując następujące kroki.

Zdekompresuj plik, który zostanie pobrany, a następnie uruchom Visual Studio 2012.
Na pasku menu wybierz kolejno opcje Plik, Otwórz i Projekt/rozwiązanie.
Przejdź do folderu, który przechowuje zdekompresowanych przykładowy kod, a następnie otwórz plik rozwiązania (.sln) dla AsTaskWhenAnyDemoVB lub AsTaskWhenAnyDemoCS.
W Solution Explorer, otwórz menu skrótów dla SequentialBlogReader projektu, a następnie wybierz jako projekt uruchamiania.
Wybierz klawisz F5, aby skompilować i uruchomić projekt.
Aby zweryfikować, że wyniki są wyświetlane w tej samej kolejności przy każdym, należy uruchomić kod kilka razy.

Możesz sprawdzić w pliku MainPage.xaml.vb lub MainPage.xaml.cs w Kod startowy budynku sekcji na końcu tematu.

Aby uzyskać informacje o cały szereg ulepszeń i rozszerzeń, które można wprowadzić do aplikacji, zobacz Utwórz blog Czytelnik.

Pobieranie gotowych aplikacji

Jeśli nie chcesz zbudować w przykładzie sobie, można pobrać kompletny przykład.Postępuj zgodnie z instrukcjami wyświetlanymi w Pobieranie kodu Starter działu, ale wybrać WhenAnyBlogReader jako Projekt uruchamiania.

Aby zweryfikować, że kanały blogu pojawiają się w różnej kolejności, należy uruchomić program kilka razy.

Możesz sprawdzić w pliku MainPage.xaml.vb lub MainPage.xaml.cs w Budowanie gotowy aplikacji sekcji na końcu tematu.

Kod startowy budynku

Można pobrać w przykładach przedstawionych w tym temacie z próbki asynchroniczne: mostkowanie z .NET do systemu Windows.Jeśli wolisz skonfigurować aplikację w górę, wykonaj następujące kroki.

Start Visual Studio 2012.
Na pasku menu wybierz Plik, Nowy, projekt.

Zostanie otwarte okno dialogowe Nowy projekt.
W Installed, Szablony kategorii, wybierz polecenie języka Visual Basic lub Visual C#, a następnie wybierz polecenie Magazynu systemu Windows na liście typów projektów.
Na liście typów projektów, wybierz polecenie App puste (XAML).
Nazwa projektu SequentialBlogReader, a następnie wybierz polecenie OK przycisk.

W Eksploratorze rozwiązań pojawi się nowy projekt.
W Solution Explorer, otwórz menu skrótów dla MainPage.xaml, a następnie wybierz Otwórz.

W XAML okno MainPage.xaml, kod ten zastąpić następujący kod.

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

Proste okno zawierające pola tekstowego i przycisku pojawia się w Projekt okno MainPage.xaml.

Aby uzyskać informacje o cały szereg ulepszeń i rozszerzenia, które można wprowadzać w interfejsie użytkownika, zobacz Utwórz blog Czytelnik.

W Solution Explorer, otwórz menu skrótów dla MainPage.xaml.vb lub MainPage.xaml.cs, a następnie wybierz View Code.

Zastąp kod w MainPage.xaml.vb lub MainPage.xaml.cs z następującego kodu.

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

Wybierz klawisz F5, aby uruchomić program, a następnie wybierz Start przycisk.

Budowanie gotowy aplikacji

Start Visual Studio 2012.
Na pasku menu wybierz Plik, Nowy, projekt.

Zostanie otwarte okno dialogowe Nowy projekt.
W Installed, Szablony kategorii, wybierz polecenie programu Visual Basic lub Visual C#, a następnie wybierz polecenie Magazynu systemu Windows.
Wybierz z listy typów projektów, App puste (XAML).
Nazwa projektu WhenAnyBlogReader, a następnie wybierz polecenie OK przycisk.

W Eksploratorze rozwiązań pojawi się nowy projekt.
W Solution Explorer, otwórz menu skrótów dla MainPage.xaml, a następnie wybierz Otwórz.