Ablaufsteuerung in asynchronen Programmen (C#)Control Flow in Async Programs (C#)

Sie können asynchrone Programme mithilfe der Schlüsselwörter async und await einfacher schreiben und verwalten.You can write and maintain asynchronous programs more easily by using the async and await keywords. Möglicherweise könnten Sie jedoch die Ergebnisse überraschen, wenn Sie die Funktionsweise Ihres Programms nicht verstehen.However, the results might surprise you if you don't understand how your program operates. In diesem Thema wird die Ablaufsteuerung durch ein einfaches asynchrones Programm nachvollzogen, um darzustellen, wann die Steuerung von einer Methode zu einer anderen springt und welche Informationen jedes Mal übertragen werden.This topic traces the flow of control through a simple async program to show you when control moves from one method to another and what information is transferred each time.

Hinweis

Die Schlüsselwörter async und await wurden in Visual Studio 2012 eingeführt.The async and await keywords were introduced in Visual Studio 2012.

Im Allgemeinen markieren Sie Methoden mit asynchronem Code mithilfe des async (C#)-Modifizierers.In general, you mark methods that contain asynchronous code with the async (C#) modifier. In einer Methode, die mit einem asynchronen Modifizierer markiert ist, können Sie einen await (C#)-Operator verwenden, um anzugeben, wo die Methode anhält, um darauf zu warten, dass ein aufgerufener asynchroner Prozess abgeschlossen wird.In a method that's marked with an async modifier, you can use an await (C#) operator to specify where the method pauses to wait for a called asynchronous process to complete. Weitere Informationen finden Sie unter Asynchrone Programmierung mit Async und Await (C#).For more information, see Asynchronous Programming with async and await (C#).

Im folgenden Beispiel werden asynchrone Methoden verwendet, um den Inhalt einer angegebenen Website als Zeichenfolge herunterzuladen und um die Länge der Zeichenfolge anzuzeigen.The following example uses async methods to download the contents of a specified website as a string and to display the length of the string. Das Beispiel enthält die folgenden beiden Methoden.The example contains the following two methods.

  • startButton_Click, die AccessTheWebAsync aufruft und das Ergebnis angezeigt.startButton_Click, which calls AccessTheWebAsync and displays the result.

  • AccessTheWebAsync, die den Inhalt einer Website als Zeichenfolge herunterlädt und die Länge der Zeichenfolge zurückgibt.AccessTheWebAsync, which downloads the contents of a website as a string and returns the length of the string. AccessTheWebAsync verwendet eine asynchrone HttpClient-Methode, GetStringAsync(String), um den Inhalt herunterzuladen.AccessTheWebAsync uses an asynchronous HttpClient method, GetStringAsync(String), to download the contents.

Nummerierte Ausgabezeilen werden über das Programm verteilt an strategischen Stellen angezeigt, die dabei helfen sollen, die Ausführung des Programms nachzuvollziehen und zu verdeutlichen, was an den markierten Punkten geschieht.Numbered display lines appear at strategic points throughout the program to help you understand how the program runs and to explain what happens at each point that is marked. Die Ausgabezeilen werden durchgehend von "ONE" (Eins) bis "SIX" (Sechs) bezeichnet.The display lines are labeled "ONE" through "SIX." Die Bezeichnungen entsprechen der Reihenfolge, in der das Programm diese Codezeilen erreicht.The labels represent the order in which the program reaches these lines of code.

Im folgenden Code wird die Gliederung des Programms angezeigt.The following code shows an outline of the program.

public partial class MainWindow : Window  
{  
    // . . .  
    private async void startButton_Click(object sender, RoutedEventArgs e)  
    {  
        // ONE  
        Task<int> getLengthTask = AccessTheWebAsync();  

        // FOUR  
        int contentLength = await getLengthTask;  

        // SIX  
        resultsTextBox.Text +=  
            String.Format("\r\nLength of the downloaded string: {0}.\r\n", contentLength);  
    }  

    async Task<int> AccessTheWebAsync()  
    {  
        // TWO  
        HttpClient client = new HttpClient();  
        Task<string> getStringTask =  
            client.GetStringAsync("http://msdn.microsoft.com");  

        // THREE                   
        string urlContents = await getStringTask;  

        // FIVE  
        return urlContents.Length;  
    }  
}  

An jeder der mit "ONE" bis "SIX" bezeichneten Stellen werden Informationen über den aktuellen Status des Programms angezeigt.Each of the labeled locations, "ONE" through "SIX," displays information about the current state of the program. Es wird die folgende Ausgabe generiert.The following output is produced.

ONE:   Entering startButton_Click.  
           Calling AccessTheWebAsync.  

TWO:   Entering AccessTheWebAsync.  
           Calling HttpClient.GetStringAsync.  

THREE: Back in AccessTheWebAsync.  
           Task getStringTask is started.  
           About to await getStringTask & return a Task<int> to startButton_Click.  

FOUR:  Back in startButton_Click.  
           Task getLengthTask is started.  
           About to await getLengthTask -- no caller to return to.  

FIVE:  Back in AccessTheWebAsync.  
           Task getStringTask is complete.  
           Processing the return statement.  
           Exiting from AccessTheWebAsync.  

SIX:   Back in startButton_Click.  
           Task getLengthTask is finished.  
           Result from AccessTheWebAsync is stored in contentLength.  
           About to display contentLength and exit.  

Length of the downloaded string: 33946.  

Das Programm einrichtenSet Up the Program

Sie können den Code, der in diesem Thema verwendet wird, von MSDN herunterladen oder Sie können ihn selbst erstellen.You can download the code that this topic uses from MSDN, or you can build it yourself.

Hinweis

Um das Beispiel ausführen zu können, muss Visual Studio 2012 oder höher sowie .NET Framework 4.5 oder höher auf Ihrem Computer installiert sein.To run the example, you must have Visual Studio 2012 or newer and the .NET Framework 4.5 or newer installed on your computer.

Das Programm herunterladenDownload the Program

Sie können die Anwendung für dieses Thema von Async Sample: Control Flow in Async Programs herunterladen.You can download the application for this topic from Async Sample: Control Flow in Async Programs. Mithilfe der folgenden Schritte wird das Programm geöffnet und ausgeführt.The following steps open and run the program.

  1. Entzippen Sie die heruntergeladene Datei und starten Sie anschließend Visual Studio.Unzip the downloaded file, and then start Visual Studio.

  2. Klicken Sie in der Menüleiste auf Datei, dann auf Öffnenund Projekt/Projektmappe.On the menu bar, choose File, Open, Project/Solution.

  3. Navigieren Sie zu dem Ordner, der den entzippten Beispielcode enthält, öffnen Sie die Projektmappendatei (SLN) und drücken Sie dann die F5-TASTE, um das Projekt zu erstellen und auszuführen.Navigate to the folder that holds the unzipped sample code, open the solution (.sln) file, and then choose the F5 key to build and run the project.

Das Programm selbst erstellenBuild the Program Yourself

Das folgende Windows Presentation Foundation (WPF)-Projekt enthält das Codebeispiel für dieses Thema.The following Windows Presentation Foundation (WPF) project contains the code example for this topic.

Um das Projekt auszuführen, führen Sie die folgenden Schritte aus:To run the project, perform the following steps:

  1. Starten Sie Visual Studio.Start Visual Studio.

  2. Wählen Sie in der Menüleiste Datei, Neu, Projektaus.On the menu bar, choose File, New, Project.

    Das Dialogfeld Neues Projekt wird angezeigt.The New Project dialog box opens.

  3. Wählen Sie im Bereich Installierte Vorlagen den Eintrag Visual C# aus, und wählen Sie dann in der Liste der Projekttypen WPF-Anwendung aus.In the Installed Templates pane, choose Visual C#, and then choose WPF Application from the list of project types.

  4. Geben Sie AsyncTracer als Name für das Projekt ein, und wählen Sie dann die Schaltfläche OK aus.Enter AsyncTracer as the name of the project, and then choose the OK button.

    Das neue Projekt wird im Projektmappen-Explorer angezeigt.The new project appears in Solution Explorer.

  5. Wählen Sie im Visual Studio Code Editor die Registerkarte MainWindow.xaml aus.In the Visual Studio Code Editor, choose the MainWindow.xaml tab.

    Wenn die Registerkarte nicht sichtbar ist, öffnen Sie das Kontextmenü für „MainWindow.xaml“ im Projektmappen-Explorer, und wählen Sie dann Code anzeigenaus.If the tab isn’t visible, open the shortcut menu for MainWindow.xaml in Solution Explorer, and then choose View Code.

  6. Ersetzen Sie den automatisch generierten Code in der XAML-Ansicht der Datei „MainWindow.xaml“ durch den folgenden Code.In the XAML view of MainWindow.xaml, replace the code with the following code.

    <Window  
            xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"  
            xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"  
            xmlns:d="http://schemas.microsoft.com/expression/blend/2008" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" mc:Ignorable="d" x:Class="AsyncTracer.MainWindow"  
            Title="Control Flow Trace" Height="350" Width="592">  
        <Grid>  
            <Button x:Name="startButton" Content="Start  
    " HorizontalAlignment="Left" Margin="250,10,0,0" VerticalAlignment="Top" Width="75" Height="24"  Click="startButton_Click" d:LayoutOverrides="GridBox"/>  
            <TextBox x:Name="resultsTextBox" HorizontalAlignment="Left" TextWrapping="Wrap" VerticalAlignment="Bottom" Width="576" Height="265" FontFamily="Lucida Console" FontSize="10" VerticalScrollBarVisibility="Visible" Grid.ColumnSpan="3"/>  
        </Grid>  
    </Window>  
    

    Ein einfaches Fenster, das ein Textfeld und eine Schaltfläche enthält, wird in der Entwurfsansicht der Datei „MainWindow.xaml“ angezeigt.A simple window that contains a text box and a button appears in the Design view of MainWindow.xaml.

  7. Fügen Sie einen Verweis für System.Net.Http hinzu.Add a reference for System.Net.Http.

  8. Öffnen Sie im Projektmappen-Explorer das Kontextmenü für „MainWindow.xaml.cs“, und wählen Sie dann Code anzeigen aus.In Solution Explorer, open the shortcut menu for MainWindow.xaml.cs, and then choose View Code.

  9. Ersetzen Sie den Code in „MainWindow.xaml.cs“ durch den folgenden Code.In MainWindow.xaml.cs, replace the code with the following code.

    using System;  
    using System.Collections.Generic;  
    using System.Linq;  
    using System.Text;  
    using System.Threading.Tasks;  
    using System.Windows;  
    using System.Windows.Controls;  
    using System.Windows.Data;  
    using System.Windows.Documents;  
    using System.Windows.Input;  
    using System.Windows.Media;  
    using System.Windows.Media.Imaging;  
    using System.Windows.Navigation;  
    using System.Windows.Shapes;  
    
    // Add a using directive and a reference for System.Net.Http;  
    using System.Net.Http;  
    
    namespace AsyncTracer  
    {  
        public partial class MainWindow : Window  
        {  
            public MainWindow()  
            {  
                InitializeComponent();  
            }  
    
            private async void startButton_Click(object sender, RoutedEventArgs e)  
            {  
                // The display lines in the example lead you through the control shifts.  
                resultsTextBox.Text += "ONE:   Entering startButton_Click.\r\n" +  
                    "           Calling AccessTheWebAsync.\r\n";  
    
                Task<int> getLengthTask = AccessTheWebAsync();  
    
                resultsTextBox.Text += "\r\nFOUR:  Back in startButton_Click.\r\n" +  
                    "           Task getLengthTask is started.\r\n" +  
                    "           About to await getLengthTask -- no caller to return to.\r\n";  
    
                int contentLength = await getLengthTask;  
    
                resultsTextBox.Text += "\r\nSIX:   Back in startButton_Click.\r\n" +  
                    "           Task getLengthTask is finished.\r\n" +  
                    "           Result from AccessTheWebAsync is stored in contentLength.\r\n" +  
                    "           About to display contentLength and exit.\r\n";  
    
                resultsTextBox.Text +=  
                    String.Format("\r\nLength of the downloaded string: {0}.\r\n", contentLength);  
            }  
    
            async Task<int> AccessTheWebAsync()  
            {  
                resultsTextBox.Text += "\r\nTWO:   Entering AccessTheWebAsync.";  
    
                // Declare an HttpClient object.  
                HttpClient client = new HttpClient();  
    
                resultsTextBox.Text += "\r\n           Calling HttpClient.GetStringAsync.\r\n";  
    
                // GetStringAsync returns a Task<string>.   
                Task<string> getStringTask = client.GetStringAsync("http://msdn.microsoft.com");  
    
                resultsTextBox.Text += "\r\nTHREE: Back in AccessTheWebAsync.\r\n" +  
                    "           Task getStringTask is started.";  
    
                // AccessTheWebAsync can continue to work until getStringTask is awaited.  
    
                resultsTextBox.Text +=  
                    "\r\n           About to await getStringTask and return a Task<int> to startButton_Click.\r\n";  
    
                // Retrieve the website contents when task is complete.  
                string urlContents = await getStringTask;  
    
                resultsTextBox.Text += "\r\nFIVE:  Back in AccessTheWebAsync." +  
                    "\r\n           Task getStringTask is complete." +  
                    "\r\n           Processing the return statement." +  
                    "\r\n           Exiting from AccessTheWebAsync.\r\n";  
    
                return urlContents.Length;  
            }  
        }  
    }  
    
  10. Drücken Sie die Taste F5, um das Programm auszuführen, und klicken Sie dann auf die Schaltfläche Starten .Choose the F5 key to run the program, and then choose the Start button.

    Es sollte folgende Ausgabe angezeigt werden.The following output should appear.

    ONE:   Entering startButton_Click.  
               Calling AccessTheWebAsync.  
    
    TWO:   Entering AccessTheWebAsync.  
               Calling HttpClient.GetStringAsync.  
    
    THREE: Back in AccessTheWebAsync.  
               Task getStringTask is started.  
               About to await getStringTask & return a Task<int> to startButton_Click.  
    
    FOUR:  Back in startButton_Click.  
               Task getLengthTask is started.  
               About to await getLengthTask -- no caller to return to.  
    
    FIVE:  Back in AccessTheWebAsync.  
               Task getStringTask is complete.  
               Processing the return statement.  
               Exiting from AccessTheWebAsync.  
    
    SIX:   Back in startButton_Click.  
               Task getLengthTask is finished.  
               Result from AccessTheWebAsync is stored in contentLength.  
               About to display contentLength and exit.  
    
    Length of the downloaded string: 33946.  
    

Ablaufverfolgung für das Programm durchführenTrace the Program

Schritte EINS und ZWEISteps ONE and TWO

Durch die ersten beiden Ausgabezeilen wird der Pfad verfolgt, während startButton_Click``AccessTheWebAsync aufruft und AccessTheWebAsync die asynchrone HttpClient-Methode GetStringAsync(String) aufruft.The first two display lines trace the path as startButton_Click calls AccessTheWebAsync, and AccessTheWebAsync calls the asynchronous HttpClient method GetStringAsync(String). Im folgenden Bild werden die Aufrufe von Methode zu Methode gezeigt.The following image outlines the calls from method to method.

Schritte EINS und ZWEISteps ONE and TWO

Der Rückgabetyp sowohl von AccessTheWebAsync als auch von client.GetStringAsync ist Task<TResult>.The return type of both AccessTheWebAsync and client.GetStringAsync is Task<TResult>. Für AccessTheWebAsync ist TResult eine ganze Zahl.For AccessTheWebAsync, TResult is an integer. Für GetStringAsync ist TResult eine Zeichenfolge.For GetStringAsync, TResult is a string. Weitere Informationen über Rückgabetypen asynchroner Methoden finden Sie unter Async Return Types (C#) (Async-Rückgabetypen (C#)).For more information about async method return types, see Async Return Types (C#).

Eine asynchrone Methode, die eine Aufgabe zurückgibt, gibt eine Aufgabeninstanz zurück, wenn die Steuerung wieder zum Aufrufer zurückwechselt.A task-returning async method returns a task instance when control shifts back to the caller. Die Steuerung kehrt von einer asynchronen Methode wieder zu deren Aufrufer zurück, wenn entweder ein await-Operator in der aufgerufenen Methode auftritt oder die aufgerufene Methode beendet wird.Control returns from an async method to its caller either when an await operator is encountered in the called method or when the called method ends. Durch die durchgehend mit "THREE" (Drei) bis "SIX" (Sechs) bezeichneten Ausgabezeilen wird dieser Teil des Prozesses verfolgt.The display lines that are labeled "THREE" through "SIX" trace this part of the process.

Schritt DREIStep THREE

In AccessTheWebAsync wird die asynchrone Methode GetStringAsync(String) aufgerufen, um den Inhalt der Zielwebseite herunterzuladen.In AccessTheWebAsync, the asynchronous method GetStringAsync(String) is called to download the contents of the target webpage. Die Steuerung kehrt von client.GetStringAsync zu AccessTheWebAsync zurück, wenn client.GetStringAsync zurückgegeben wird.Control returns from client.GetStringAsync to AccessTheWebAsync when client.GetStringAsync returns.

Die client.GetStringAsync-Methode gibt eine Zeichenfolgenaufgabe zurück, die der getStringTask-Variablen in AccessTheWebAsync zugewiesen wird.The client.GetStringAsync method returns a task of string that’s assigned to the getStringTask variable in AccessTheWebAsync. Die folgende Zeile im Beispielprogramm zeigt den Aufruf von client.GetStringAsync und die Zuweisung.The following line in the example program shows the call to client.GetStringAsync and the assignment.

Task<string> getStringTask = client.GetStringAsync("http://msdn.microsoft.com");  

Sie können sich die Aufgabe als eine Zusage von client.GetStringAsync vorstellen, schließlich eine tatsächliche Zeichenfolge zu erzeugen.You can think of the task as a promise by client.GetStringAsync to produce an actual string eventually. In der Zwischenzeit, wenn AccessTheWebAsync auszuführende Aufgaben hat, die nicht von der zugesagten Zeichenfolge von client.GetStringAsync abhängen, können diese Aufgaben fortgesetzt werden, während client.GetStringAsync wartet.In the meantime, if AccessTheWebAsync has work to do that doesn't depend on the promised string from client.GetStringAsync, that work can continue while client.GetStringAsync waits. Im Beispiel bieten die folgenden, mit „THREE“ bezeichneten Ausgabezeilen die Gelegenheit, um unabhängige Aufgaben auszuführen.In the example, the following lines of output, which are labeled "THREE," represent the opportunity to do independent work

THREE: Back in AccessTheWebAsync.  
           Task getStringTask is started.  
           About to await getStringTask & return a Task<int> to startButton_Click.  

Durch die folgende Anweisung wird die Ausführung in AccessTheWebAsync angehalten, wenn getStringTask erwartet wird.The following statement suspends progress in AccessTheWebAsync when getStringTask is awaited.

string urlContents = await getStringTask;  

Das folgende Bild zeigt die Ablaufsteuerung von client.GetStringAsync bis zur Zuweisung von getStringTask und von der Erstellung von getStringTask bis zur Anwendung eines await-Operators an.The following image shows the flow of control from client.GetStringAsync to the assignment to getStringTask and from the creation of getStringTask to the application of an await operator.

Schritt DREIStep THREE

Durch den await-Ausdruck wird AccessTheWebAsync angehalten, bis client.GetStringAsync zurückgegeben wird.The await expression suspends AccessTheWebAsync until client.GetStringAsync returns. In der Zwischenzeit kehrt die Steuerung zum Aufrufer von AccessTheWebAsync, startButton_Click, zurück.In the meantime, control returns to the caller of AccessTheWebAsync, startButton_Click.

Hinweis

In der Regel warten Sie sofort auf den Aufruf einer asynchronen Methode.Typically, you await the call to an asynchronous method immediately. Beispielsweise könnte die folgende Zuweisung den vorherigen Code ersetzen, der getStringTask erstellt und anschließend darauf wartet: string urlContents = await client.GetStringAsync("http://msdn.microsoft.com");For example, the following assignment could replace the previous code that creates and then awaits getStringTask: string urlContents = await client.GetStringAsync("http://msdn.microsoft.com");

In diesem Thema wird der await-Operator später angewendet, um die Ausgabezeilen anzupassen, die die Ablaufsteuerung durch das Programm markieren.In this topic, the await operator is applied later to accommodate the output lines that mark the flow of control through the program.

Schritt VIERStep FOUR

Der deklarierte Rückgabetyp von AccessTheWebAsync ist Task<int>.The declared return type of AccessTheWebAsync is Task<int>. Wenn AccessTheWebAsync angehalten wird, wird daher eine Ganzzahlaufgabe an startButton_Click zurückgegeben.Therefore, when AccessTheWebAsync is suspended, it returns a task of integer to startButton_Click. Sie sollten verstanden haben, dass die zurückgegebene Aufgabe nicht getStringTask ist.You should understand that the returned task isn’t getStringTask. Die zurückgegebene Aufgabe ist eine neue Ganzzahlaufgabe, die die verbleibenden Aufgaben in der angehaltenen Methode, AccessTheWebAsync, darstellt.The returned task is a new task of integer that represents what remains to be done in the suspended method, AccessTheWebAsync. Die Aufgabe ist eine Zusage von AccessTheWebAsync, eine ganze Zahl zu erzeugen, wenn die Aufgabe abgeschlossen wird.The task is a promise from AccessTheWebAsync to produce an integer when the task is complete.

Die folgende Anweisung weist diese Aufgabe der getLengthTask-Variablen zu.The following statement assigns this task to the getLengthTask variable.

Task<int> getLengthTask = AccessTheWebAsync();  

Wie in AccessTheWebAsync kann startButton_Click mit Aufgaben fortsetzen, die nicht von den Ergebnissen der asynchronen Aufgabe (getLengthTask) abhängen, bis diese Aufgabe erwartet wird.As in AccessTheWebAsync, startButton_Click can continue with work that doesn’t depend on the results of the asynchronous task (getLengthTask) until the task is awaited. Die folgenden Ausgabezeilen stellen diese Aufgaben dar.The following output lines represent that work.

FOUR:  Back in startButton_Click.  
           Task getLengthTask is started.  
           About to await getLengthTask -- no caller to return to.  

Die Ausführung von startButton_Click wird angehalten, wenn getLengthTask erwartet wird.Progress in startButton_Click is suspended when getLengthTask is awaited. Durch die folgende Zuweisungsanweisung wird startButton_Click angehalten, bis AccessTheWebAsync abgeschlossen ist.The following assignment statement suspends startButton_Click until AccessTheWebAsync is complete.

int contentLength = await getLengthTask;  

In der folgenden Abbildung veranschaulichen die Pfeile die Ablaufsteuerung vom await-Ausdruck in AccessTheWebAsync zur Zuweisung eines Werts an getLengthTask, gefolgt von normaler Verarbeitung in startButton_Click bis getLengthTask erwartet wird.In the following illustration, the arrows show the flow of control from the await expression in AccessTheWebAsync to the assignment of a value to getLengthTask, followed by normal processing in startButton_Click until getLengthTask is awaited.

Schritt VIERStep FOUR

Schritt FÜNFStep FIVE

Wenn client.GetStringAsync signalisiert, dass es abgeschlossen ist, wird die Verarbeitung in AccessTheWebAsync aus dem Anhalten freigegeben und kann nach dem await-Ausdruck fortgesetzt werden.When client.GetStringAsync signals that it’s complete, processing in AccessTheWebAsync is released from suspension and can continue past the await statement. Die folgenden Ausgabezeilen stellen die Wiederaufnahme der Verarbeitung dar.The following lines of output represent the resumption of processing.

FIVE:  Back in AccessTheWebAsync.  
           Task getStringTask is complete.  
           Processing the return statement.  
           Exiting from AccessTheWebAsync.  

Der Operand der return-Anweisung, urlContents.Length, wird in der Aufgabe gespeichert, die AccessTheWebAsync zurückgibt.The operand of the return statement, urlContents.Length, is stored in the task that AccessTheWebAsync returns. Der await-Ausdruck ruft diesen Wert von getLengthTask in startButton_Click ab.The await expression retrieves that value from getLengthTask in startButton_Click.

Im folgenden Bild wird die Übertragung der Steuerung gezeigt, nachdem client.GetStringAsync (und getStringTask) abgeschlossen sind.The following image shows the transfer of control after client.GetStringAsync (and getStringTask) are complete.

Schritt FÜNFStep FIVE

AccessTheWebAsync wird bis zum Abschluss ausgeführt und die Steuerung kehrt zu startButton_Click zurück, das den Abschluss erwartet.AccessTheWebAsync runs to completion, and control returns to startButton_Click, which is awaiting the completion.

Schritt SECHSStep SIX

Wenn AccessTheWebAsync signalisiert, dass es abgeschlossen ist, kann die Verarbeitung nach der await-Anweisung in startButton_Async fortgesetzt werden.When AccessTheWebAsync signals that it’s complete, processing can continue past the await statement in startButton_Async. Für das Programm gibt es eigentlich nichts mehr zu tun.In fact, the program has nothing more to do.

Die folgenden Ausgabezeilen stellen die Wiederaufnahme der Verarbeitung in startButton_Async dar:The following lines of output represent the resumption of processing in startButton_Async:

SIX:   Back in startButton_Click.  
           Task getLengthTask is finished.  
           Result from AccessTheWebAsync is stored in contentLength.  
           About to display contentLength and exit.  

Der await-Ausdruck ruft von getLengthTask den ganzzahligen Wert ab, der der Operand der return-Anweisung in AccessTheWebAsync ist.The await expression retrieves from getLengthTask the integer value that’s the operand of the return statement in AccessTheWebAsync. Die folgende Anweisung weist diesen Wert der contentLength-Variablen zu.The following statement assigns that value to the contentLength variable.

int contentLength = await getLengthTask;  

Im folgenden Bild wird die Rückgabe der Steuerung von AccessTheWebAsync an startButton_Click gezeigt.The following image shows the return of control from AccessTheWebAsync to startButton_Click.

Schritt SECHSStep SIX

Siehe auchSee Also

Asynchronous Programming with async and await (C#) (Asynchrone Programmierung mit Async und Await (C#))Asynchronous Programming with async and await (C#)
Asynchrone Rückgabetypen (C#)Async Return Types (C#)
Exemplarische Vorgehensweise: Zugreifen auf das Web mit „async“ und „await“ (C#)Walkthrough: Accessing the Web by Using async and await (C#)
Thema mit einem asynchronen Beispiel für die Ablaufsteuerung in asynchronen Programmen (C# und Visual Basic)Async Sample: Control Flow in Async Programs (C# and Visual Basic)