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

  • Artikel

Sie können Ihre Ressourcen maximieren, indem Sie die Funktionen von .NET Framework und Windows-Runtime kombinieren. Das Beispiel in diesem Thema zeigt, wie Sie mithilfe einer Instanz des .NET Framework CancellationToken einer App, die eine Windows-Runtime-Methode verwendet, um Blogfeeds aus dem Internet herunterzuladen, eine Schaltfläche zum Abbrechen hinzufügen.

Hinweis

Für die Ausführung des Beispiels muss Windows 8 auf dem Computer installiert sein.Wenn Sie das Beispiel aus Visual Studio heraus ausführen möchten, muss Visual Studio 2012, Visual Studio 2013, Visual Studio Express 2012 für Windows 8 oder Visual Studio Express 2013 für Windows installiert sein.

AsTask stellt eine Brücke bereit

Das Abbruchtoken erfordert Task-Instanzen, die Windows-Runtime-Methode erzeugt jedoch IAsyncOperationWithProgress-Instanzen. Sie können die AsTask``2-Erweiterungsmethode in .NET Framework verwenden, um zwischen diesen zu überbrücken.

Die DownloadBlogsAsync-Methode im Beispiel erledigt den Großteil der Arbeit.

Async Function DownloadBlogsAsync(ct As CancellationToken) As Task
    Dim client As Windows.Web.Syndication.SyndicationClient = New SyndicationClient()

    Dim uriList = CreateUriList()

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


    ' The following code avoids the use of implicit typing (var) so that you  
    ' can identify the types clearly. 

    For Each uri In uriList
        ' ***These three lines are combined in the single statement that follows them. 
        'Dim feedOp As IAsyncOperationWithProgress(Of SyndicationFeed, RetrievalProgress) = 
        '    client.RetrieveFeedAsync(uri) 
        'Dim feedTask As Task(Of SyndicationFeed) = feedOp.AsTask(ct) 
        'Dim feed As SyndicationFeed = Await feedTask 

        ' ***You can combine the previous three steps in one expression. 
        Dim feed As SyndicationFeed = Await client.RetrieveFeedAsync(uri).AsTask(ct)

        DisplayResults(feed, ct)
    Next 
End Function

async Task DownloadBlogsAsync(CancellationToken ct)
{
    Windows.Web.Syndication.SyndicationClient client = new SyndicationClient();

    var uriList = CreateUriList();

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

    // The following code avoids the use of implicit typing (var) so that you  
    // can identify the types clearly. 

    foreach (var uri in uriList)
    {
        // ***These three lines are combined in the single statement that follows them. 
        //IAsyncOperationWithProgress<SyndicationFeed, RetrievalProgress> feedOp =  
        //    client.RetrieveFeedAsync(uri); 
        //Task<SyndicationFeed> feedTask = feedOp.AsTask(ct); 
        //SyndicationFeed feed = await feedTask; 

        // ***You can combine the previous three steps in one expression.
        SyndicationFeed feed = await client.RetrieveFeedAsync(uri).AsTask(ct);

        DisplayResults(feed);
    }
}

Im auskommentierten Abschnitt in der Schleife sind die Übergangsschritte ausführlich aufgeführt.

  • Durch den Aufruf von SyndicationClient.RetrieveFeedAsync wird ein asynchroner Vorgang gestartet, mit dem ein Blogfeed von einer angegebenen URI heruntergeladen wird. Der asynchrone Vorgang ist eine IAsyncOperationWithProgress-Instanz.

    Dim feedOp As IAsyncOperationWithProgress(Of SyndicationFeed, RetrievalProgress) = 
    client.RetrieveFeedAsync(uri)

    IAsyncOperationWithProgress<SyndicationFeed, RetrievalProgress> feedOp =  
    client.RetrieveFeedAsync(uri);

  • Da die Abbruchfunktionen in .NET Framework, die Sie verwenden möchten, Aufgaben erfordern, wird im Code AsTask``1 angewendet, um die IAsyncOperationWithProgress-Instanz als Task darzustellen. Insbesondere wird im Code eine AsTask-Überladung angewendet, die ein CancellationToken-Argument akzeptiert.

    Dim feedTask As Task(Of SyndicationFeed) = feedOp.AsTask(ct)

    Task<SyndicationFeed> feedTask = feedOp.AsTask(ct);

  • Schließlich erwartet der await- oder Await-Operator die Aufgabe, um das SyndicationFeed-Ergebnis abzurufen.

    Dim feed As SyndicationFeed = Await feedTask

    SyndicationFeed feed = await feedTask;

Weitere Informationen zu AsTask finden Sie unter Erweitern des Startcodes im Artikel WhenAny: Überbrückung zwischen .NET Framework und Windows-Runtime (C# und Visual Basic).

Relevante Punkte

Sie können das gesamte Beispiel durchgehen, indem Sie einen Bildlauf bis zum Ende dieses Themas durchführen, indem Sie das Beispiel auf Ihren Computer herunterladen oder indem Sie das Beispiel erstellen. Weitere Informationen sowie Anweisungen finden Sie unter Einrichten des Beispiels.

Wenn Sie das Beispiel durchgehen, werden Sie Sternchen bemerken, die wichtige Aspekte hervorheben. Es wird empfohlen, diesen Abschnitt zu lesen, um diese Punkte besser zu verstehen, insbesondere wenn Sie CancellationToken zuvor noch nicht verwendet haben.

Um eine Schaltfläche zum Abbrechen zu implementieren, muss der Code die folgenden Elemente enthalten.

  • Eine CancellationTokenSource-Variable, cts, die im Bereich für alle Methoden liegt, die darauf zugreifen.

    Public NotInheritable Class MainPage
    Inherits Page

    ' ***Declare a System.Threading.CancellationTokenSource. 
    Dim cts As CancellationTokenSource

    public sealed partial class MainPage : Page
{
    // ***Declare a System.Threading.CancellationTokenSource.
    CancellationTokenSource cts;

  • Ein Ereignishandler für die Schaltfläche Abbrechen. Der Ereignishandler verwendet die CancellationTokenSource.Cancel-Methode, um cts bei Abbruchanforderungen durch den Benutzer zu benachrichtigen.

    ' ***Add an event handler for the Cancel button. 
Private Sub cancelButton_Click(sender As Object, e As RoutedEventArgs)
    If cts IsNot Nothing Then
        cts.Cancel()
        ResultsTextBox.Text &= vbCrLf & "Downloads canceled by the Cancel button." 
    End If 
End Sub

    // ***Add an event handler for the Cancel button. 
private void CancelButton_Click(object sender, RoutedEventArgs e)
{
    if (cts != null)
    {
        cts.Cancel();
        ResultsTextBox.Text += "\r\nDownloads canceled by the Cancel button.";
    }
}

  • Den Ereignishandler StartButton_Click für die Schaltfläche Start, der die folgenden Aktionen enthält.

    • Der Ereignishandler instanziiert die CancellationTokenSource, cts.

      cts = New CancellationTokenSource()

      // ***Instantiate the CancellationTokenSource.
cts = new CancellationTokenSource();

    • Im Aufruf von DownloadBlogsAsync, durch den die Blogfeeds heruntergeladen werden, sendet der Code die CancellationTokenSource.Token-Eigenschaft von cts als Argument. Die Token-Eigenschaft gibt die Meldung weiter, wenn ein Abbruch angefordert wird.

      Await DownloadBlogsAsync(cts.Token)

      await DownloadBlogsAsync(cts.Token);

    • Der Aufruf von DownloadBlogsAsync wird in einer try-catch-Anweisung zusammengefasst, die einen Catch-Block für die OperationCanceledException enthält, die entsteht, wenn Sie die Schaltfläche Abbrechen auswählen. Der Aufrufer der asynchronen Methode definiert, welche Aktion auszuführen ist. In diesem Beispiel wird nur eine Nachricht angezeigt.

      Im folgenden Code wird die vollständige try-catch-Anweisung angezeigt.

      Try 
    ' ***Send a token to carry the message if cancellation is requested.
    Await DownloadBlogsAsync(cts.Token)

    ' ***Check for cancellations. 
Catch op As OperationCanceledException
    ' In practice, this catch block often is empty. It is used to absorb 
    ' the exception,
    ResultsTextBox.Text &= vbCrLf & "Cancellation exception bubbles up to the caller." 

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

      try
{
    // ***Send a token to carry the message if cancellation is requested.
    await DownloadBlogsAsync(cts.Token);
}
// ***Check for cancellations. 
catch (OperationCanceledException)
{
    // In practice, this catch block often is empty. It is used to absorb 
    // the exception,
    ResultsTextBox.Text += "\r\nCancellation exception bubbles up to the caller.";
}
// Check for other exceptions. 
catch (Exception ex)
{
    ResultsTextBox.Text =
        "Page could not be loaded.\r\n" + "Exception: " + ex.ToString();
}

  • Wie in diesem Thema bereits beschrieben, ruft die DownloadBlogsAsync-Methode die Windows-Runtime-Methode RetrieveFeedAsync auf und wendet eine .NET Framework-Erweiterungsmethode, AsTask, auf die zurückgegebene IAsyncOperation-Instanz an. AsTask stellt die Instanz als eine Task dar, sodass Sie das Abbruchtoken an den asynchronen Vorgang senden können. Das Token enthält die Meldung, wenn Sie die Schaltfläche Abbrechen auswählen.

    Beachten Sie, dass durch Verwendung von AsTask der Code dieselbe CancellationToken-Instanz sowohl an eine Windows-Runtime-Methode (RetrieveFeedAsync) als auch eine .NET Framework-Methode (DownloadBlogsAsync) übergeben kann.

    Die folgende Zeile zeigt diesen Teil des Codes.

    Dim feed As SyndicationFeed = Await client.RetrieveFeedAsync(uri).AsTask(ct)

    SyndicationFeed feed = await client.RetrieveFeedAsync(uri).AsTask(ct);

  • Wenn Sie die App nicht abbrechen, wird folgende Ausgabe erzeugt.

    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
    Windows Restart and Recovery Recipe, 3/21/2011 2:13:24 PM -07:00

Extreme Windows Blog
    Samsung Series 9 27” PLS Display: Amazing Picture, 8/20/2012 2:41:48 PM -07:00
    NVIDIA GeForce GTX 660 Ti Graphics Card: Affordable Graphics Powerhouse, 8/16/2012 10:56:19 AM -07:00
    HP Z820 Workstation: Rising To the Challenge, 8/14/2012 1:57:01 PM -07:00

Blogging Windows
    Windows Upgrade Offer Registration Now Available, 8/20/2012 1:01:00 PM -07:00
    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

Windows for your Business
    What Windows 8 RTM Means for Businesses, 8/1/2012 9:01:00 AM -07:00
    Higher-Ed Learning with Windows 8, 7/26/2012 12:03:00 AM -07:00
    Second Public Beta of App-V 5.0 Now Available with Office Integration, 7/24/2012 10:07:26 AM -07:00

Windows Experience Blog
    Tech Tuesday Live Twitter Chat with Microsoft Hardware, 8/20/2012 2:20:57 AM -07:00
    New Colors and New Artist Series Mice from Microsoft Hardware, 8/15/2012 12:06:35 AM -07:00
    Tech Tuesday Live Twitter Chat with HP on Keeping Kids Safe as They Head Back to School #winchat, 8/13/2012 12:24:18 PM -07:00

Windows Security Blog
    Dealing with Fake Tech Support & Phone Scams, 6/16/2011 1:53:00 PM -07:00
    Combating social engineering tactics, like cookiejacking, to stay safer online, 5/28/2011 12:02:26 PM -07:00
    Windows 7 is now Common Criteria Certified!, 4/27/2011 9:35:01 AM -07:00

Windows Home Server Blog
    Connecting Windows 8 Consumer Preview with Windows Home Server, 3/25/2012 9:06:00 AM -07:00
    Viridian PC Systems announces two new server models are available to order, 10/3/2011 12:36:00 PM -07:00
    PC Specialist to release Windows Home Server 2011, 9/27/2011 10:27:37 AM -07:00

Springboard Series Blog
    Windows 8 Is Ready For Your Enterprise, 8/16/2012 9:59:00 AM -07:00
    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

    Wenn Sie die Schaltfläche Abbrechen auswählen, bevor die App das Herunterladen des Inhalts abgeschlossen hat, wird eine ähnliche Ausgabe wie die folgende erzeugt.

    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
    Windows Restart and Recovery Recipe, 3/21/2011 2:13:24 PM -07:00

Extreme Windows Blog
    Samsung Series 9 27” PLS Display: Amazing Picture, 8/20/2012 2:41:48 PM -07:00
    NVIDIA GeForce GTX 660 Ti Graphics Card: Affordable Graphics Powerhouse, 8/16/2012 10:56:19 AM -07:00
    HP Z820 Workstation: Rising To the Challenge, 8/14/2012 1:57:01 PM -07:00

Blogging Windows
    Windows Upgrade Offer Registration Now Available, 8/20/2012 1:01:00 PM -07:00
    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

Windows for your Business
    What Windows 8 RTM Means for Businesses, 8/1/2012 9:01:00 AM -07:00
    Higher-Ed Learning with Windows 8, 7/26/2012 12:03:00 AM -07:00
    Second Public Beta of App-V 5.0 Now Available with Office Integration, 7/24/2012 10:07:26 AM -07:00

Downloads canceled by the Cancel button.
Cancellation exception bubbles up to the caller.

Einrichten des Beispiels

Sie können die App herunterladen, sie selbst erstellen oder den Code am Ende dieses Themas durchgehen, ohne sie zu implementieren. Auf dem Computer müssen Visual Studio und Windows 8 installiert sein, um diese App auszuführen.

So laden Sie die fertige App herunter

  1. Laden Sie die komprimierte Datei aus dem Thema mit einem asynchronen Beispiel für die Überbrückung zwischen .NET und Windows-Runtime ("AsTask" & "Cancellation") herunter.

  2. Dekomprimieren Sie die heruntergeladene Datei, und starten Sie dann Visual Studio.

  3. Klicken Sie in der Menüleiste auf Datei, dann auf Öffnen und Projekt/Projektmappe.

  4. Navigieren Sie zu dem Ordner mit dem dekomprimierten Beispielcode, und öffnen Sie die Projektmappendatei (SLN-Datei).

  5. Drücken Sie zum Erstellen und Ausführen des Projekts die Taste F5.

    Führen Sie den Code mehrmals aus, um sicherzustellen,, dass Sie an verschiedenen Punkten abbrechen können.

So erstellen Sie die fertige App

  1. Starten Sie Visual Studio.

  2. Wählen Sie in der Menüleiste Datei, Neu, Projekt aus.

    Das Dialogfeld Neues Projekt wird angezeigt.

  3. Wählen Sie Visual Basic oder Visual C# in der Kategorie Installiert, Vorlagen aus, und wählen Sie dann Windows Store aus.

  4. Wählen Sie in der Liste der Projekttypen Leere App (XAML) aus.

  5. Nennen Sie das Projekt BlogFeedWithCancellation, und wählen Sie dann die Schaltfläche OK aus.

    Das neue Projekt wird im Projektmappen-Explorer angezeigt.

  6. Öffnen Sie im Projektmappen-Explorer das Kontextmenü für die MainPage.xaml-Datei, und wählen Sie Öffnen aus.

  7. Ersetzen Sie den automatisch generierten Code im Fenster XAML der MainPage.xaml-Datei durch den folgenden Code.

    <Page
    x:Class="BlogFeedWithCancellation.MainPage"
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:BlogFeedWithCancellation"
    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="Left" Margin="325,77,0,0" VerticalAlignment="Top" Click="StartButton_Click" Height="145" Background="#FFA89B9B" FontSize="36" Width="355"  />
        <Button x:Name="CancelButton" Content="Cancel" HorizontalAlignment="Left" Margin="684,77,0,0" VerticalAlignment="Top" Height="145" Background="#FFA89B9B" Click="CancelButton_Click" FontSize="36" Width="355"  />
        <TextBox x:Name="ResultsTextBox" HorizontalAlignment="Left" Margin="325,222,0,0" TextWrapping="Wrap" VerticalAlignment="Top" Height="546" FontSize="10" ScrollViewer.VerticalScrollBarVisibility="Visible" Width="711" />
    </Grid>
</Page>

    Ein einfaches Fenster mit einem Textfeld, eine Startschaltfläche und eine Schaltfläche zum Abbrechen werden im Fenster Entwurf von "MainPage.xaml" angezeigt.

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

  9. 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
' Add an Imports statement for Tasks. 
Imports System.Threading.Tasks
' Add an Imports statement for CancellationToken. 
Imports System.Threading


Public NotInheritable Class MainPage
    Inherits Page

    ' ***Declare a System.Threading.CancellationTokenSource. 
    Dim cts As CancellationTokenSource

    Private Async Sub StartButton_Click(sender As Object, e As RoutedEventArgs)
        ResultsTextBox.Text = "" 
        ' Prevent unexpected reentrance.
        StartButton.IsEnabled = False 

        ' ***Instantiate the CancellationTokenSource.
        cts = New CancellationTokenSource()

        Try 
            ' ***Send a token to carry the message if cancellation is requested.
            Await DownloadBlogsAsync(cts.Token)

            ' ***Check for cancellations. 
        Catch op As OperationCanceledException
            ' In practice, this catch block often is empty. It is used to absorb 
            ' the exception,
            ResultsTextBox.Text &= vbCrLf & "Cancellation exception bubbles up to the caller." 

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

        ' ***Set the CancellationTokenSource to null when the work is complete.
        cts = Nothing 

        ' In case you want to try again.
        StartButton.IsEnabled = True 
    End Sub 


    ' Provide a parameter for the CancellationToken.
    Async Function DownloadBlogsAsync(ct As CancellationToken) As Task
        Dim client As Windows.Web.Syndication.SyndicationClient = New SyndicationClient()

        Dim uriList = CreateUriList()

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


        ' The following code avoids the use of implicit typing (var) so that you  
        ' can identify the types clearly. 

        For Each uri In uriList
            ' ***These three lines are combined in the single statement that follows them. 
            'Dim feedOp As IAsyncOperationWithProgress(Of SyndicationFeed, RetrievalProgress) = 
            '    client.RetrieveFeedAsync(uri) 
            'Dim feedTask As Task(Of SyndicationFeed) = feedOp.AsTask(ct) 
            'Dim feed As SyndicationFeed = Await feedTask 

            ' ***You can combine the previous three steps in one expression. 
            Dim feed As SyndicationFeed = Await client.RetrieveFeedAsync(uri).AsTask(ct)

            DisplayResults(feed, ct)
        Next 
    End Function 


    ' ***Add an event handler for the Cancel button. 
    Private Sub cancelButton_Click(sender As Object, e As RoutedEventArgs)
        If cts IsNot Nothing Then
            cts.Cancel()
            ResultsTextBox.Text &= vbCrLf & "Downloads canceled by the Cancel button." 
        End If 
    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/business/atom.aspx"),
                    New Uri("https://windowsteamblog.com/windows/b/windowsexperience/atom.aspx"),
                    New Uri("https://windowsteamblog.com/windows/b/windowssecurity/atom.aspx"),
                    New Uri("https://windowsteamblog.com/windows/b/windowshomeserver/atom.aspx"),
                    New Uri("https://windowsteamblog.com/windows/b/springboard/atom.aspx")
                }
        Return uriList
    End Function 


    ' You can pass the CancellationToken to this method if you think you might use a 
    ' cancellable API here in the future. 
    Sub DisplayResults(sf As SyndicationFeed, ct As CancellationToken)
        ' Title of the blog.
        ResultsTextBox.Text &= sf.Title.Text & vbCrLf

        ' Titles and dates for the first three blog posts. 
        For i As Integer = 0 To If(sf.Items.Count >= 3, 2, sf.Items.Count)
            ResultsTextBox.Text &= vbTab & sf.Items.ElementAt(i).Title.Text & ", " &
                    sf.Items.ElementAt(i).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;
// Add a using directive for Tasks. 
using System.Threading.Tasks;
// Add a using directive for CancellationToken. 
using System.Threading;


namespace BlogFeedWithCancellation
{
    public sealed partial class MainPage : Page
    {
        // ***Declare a System.Threading.CancellationTokenSource.
        CancellationTokenSource cts;

        public MainPage()
        {
            this.InitializeComponent();
        }


        private async void StartButton_Click(object sender, RoutedEventArgs e)
        {
            ResultsTextBox.Text = "";
            // Prevent unexpected reentrance.
            StartButton.IsEnabled = false;

            // ***Instantiate the CancellationTokenSource.
            cts = new CancellationTokenSource();

            try
            {
                // ***Send a token to carry the message if cancellation is requested.
                await DownloadBlogsAsync(cts.Token);
            }
            // ***Check for cancellations. 
            catch (OperationCanceledException)
            {
                // In practice, this catch block often is empty. It is used to absorb 
                // the exception,
                ResultsTextBox.Text += "\r\nCancellation exception bubbles up to the caller.";
            }
            // Check for other exceptions. 
            catch (Exception ex)
            {
                ResultsTextBox.Text =
                    "Page could not be loaded.\r\n" + "Exception: " + ex.ToString();
            }

            // ***Set the CancellationTokenSource to null when the work is complete.
            cts = null;

            // In case you want to try again.
            StartButton.IsEnabled = true;
        }


        // ***Provide a parameter for the CancellationToken.
        async Task DownloadBlogsAsync(CancellationToken ct)
        {
            Windows.Web.Syndication.SyndicationClient client = new SyndicationClient();

            var uriList = CreateUriList();

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

            // The following code avoids the use of implicit typing (var) so that you  
            // can identify the types clearly. 

            foreach (var uri in uriList)
            {
                // ***These three lines are combined in the single statement that follows them. 
                //IAsyncOperationWithProgress<SyndicationFeed, RetrievalProgress> feedOp =  
                //    client.RetrieveFeedAsync(uri); 
                //Task<SyndicationFeed> feedTask = feedOp.AsTask(ct); 
                //SyndicationFeed feed = await feedTask; 

                // ***You can combine the previous three steps in one expression.
                SyndicationFeed feed = await client.RetrieveFeedAsync(uri).AsTask(ct);

                DisplayResults(feed);
            }
        }



        // ***Add an event handler for the Cancel button. 
        private void CancelButton_Click(object sender, RoutedEventArgs e)
        {
            if (cts != null)
            {
                cts.Cancel();
                ResultsTextBox.Text += "\r\nDownloads canceled by the Cancel button.";
            }
        }


        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/business/atom.aspx"),
                new Uri("https://windowsteamblog.com/windows/b/windowsexperience/atom.aspx"),
                new Uri("https://windowsteamblog.com/windows/b/windowssecurity/atom.aspx"),
                new Uri("https://windowsteamblog.com/windows/b/windowshomeserver/atom.aspx"),
                new Uri("https://windowsteamblog.com/windows/b/springboard/atom.aspx")
            };
            return uriList;
        }


        // You can pass the CancellationToken to this method if you think you might use a 
        // cancellable API here in the future. 
        void DisplayResults(SyndicationFeed sf)
        {
            // Title of the blog.
            ResultsTextBox.Text += sf.Title.Text + "\r\n";

            // Titles and dates for the first three blog posts. 
            for (int i = 0; i < (sf.Items.Count < 3 ? sf.Items.Count : 3); i++)    // Is Math.Min better?
            {
                ResultsTextBox.Text += "\t" + sf.Items.ElementAt(i).Title.Text + ", " +
                    sf.Items.ElementAt(i).PublishedDate.ToString() + "\r\n";
            }

            ResultsTextBox.Text += "\r\n";
        }
    }
}

  10. Drücken Sie die Taste F5, um das Programm auszuführen, und klicken Sie dann auf die Schaltfläche Starten.

Siehe auch

Konzepte

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

Eine asynchrone Aufgabe oder Aufgabenliste abbrechen (C# und Visual Basic)

Asynchrone Aufgaben nach einer Zeitperiode abbrechen (C# und Visual Basic)

Verbleibende asynchrone Aufgaben nach Abschluss einer Aufgabe abbrechen (C# und Visual Basic)

Abbruchtoken