Exemplarische Vorgehensweise: Verwenden des Debuggers mit Async-Methoden

Artikel
02/26/2013

Indem Sie die asynchrone Funktion verwenden, können Sie in asynchronen Methoden aufrufen, ohne Rückrufe zu verwenden oder den Code über mehrere Methoden oder Lambda-Ausdrücken zu teilen. Um synchronen Codes asynchron auszuführen, rufen Sie eine asynchrone Methode anstelle einer synchronen Methode auf und einige Schlüsselwörter dem Code hinzu. Weitere Informationen finden Sie unter Asynchrone Programmierung mit Async und Await (C# und Visual Basic).

Im Visual Studio-Debugger können Sie Einzelschritt, Prozedurschritt und Ausführen bis Rücksprung Befehle mit der Async-Funktion verwenden. Sie können auch weiterhin, um Haltepunkte zu verwenden, um die Ablaufsteuerung an einer Anweisung besonders anzuzeigen, die einen Erwartungsoperator enthält. In dieser exemplarischen Vorgehensweise führen Sie folgende Aufgaben aus, die Sie in jeder beliebigen Reihenfolge ausgeführt werden können.

Bieten Sie die Ablaufsteuerung an einer Erwartungsanweisung, indem Sie Haltepunkte verwenden.
Machen Sie das Verhalten der Einzelschritt und Prozedurschritt Befehle an den Anweisungen, die einen Erwartungsoperator enthalten.
Machen Sie das Verhalten des Befehls Ausführen bis Rücksprung, wenn Sie es aus einer asynchronen Methode verwenden.

Haltepunkte, um die Ablaufsteuerung anzuzeigen

Wenn Sie eine Methode mit dem Modifizierer Async (Visual Basic) oder async (C#) markieren, können Sie den Operator Await (Visual Basic) oder await (C#) in der Methode verwenden. Um einen Erwartungsausdruck zu erstellen, ordnen Sie den Erwartungsoperator mit einer Aufgabe zu. Wenn ein Erwartungsausdruck für die Aufgabe aufgerufen wird, beendet die aktuelle Methode sofort und gibt eine andere Aufgabe zurück. Wenn die Aufgabe, die mit den Erwartungsoperatorenden zugeordnet ist, führen in derselben Methode fortgesetzt. Weitere Informationen finden Sie unter Ablaufsteuerung in asynchronen Programmen (C# und Visual Basic).

Hinweis

Eine asynchrone Methode wird an den Aufrufer zurück, wenn eine es zuerst das erwartete Objekt entdeckt, das noch nicht vollständig ist, oder es das Ende der asynchronen Methode erreicht, das zuerst auftritt.

Hinweis

Die Konsolen-Apps in diesen Beispielen verwenden Wait-Methode, um die Anwendung die Beendigung in Main zu verhindern.Sie sollten die Wait-Methode außerhalb der Konsolenanwendungen nicht verwenden, da eine Deadlocksituation auftreten kann.

Die folgenden Prozedursatzhaltepunkte, zu veranschaulichen, was geschieht, wenn die Anwendung eine Erwartungsanweisung erreicht. Sie können auch die Ablaufsteuerung veranschaulichen, indem Sie Debug.WriteLine-Anweisungen hinzufügen.

Erstellen Sie eine Konsolenanwendung, und fügen Sie dann den folgenden Code in die Datei ein:

' Breakpoints to show control flow.
Imports System.Threading.Tasks

Module Module1
    Sub Main()
        Dim theTask = ProcessAsync()
        Dim x = 0 ' set breakpoint
        theTask.Wait()
    End Sub

    Async Function ProcessAsync() As Task
        Dim result = Await DoSomethingAsync()  ' set breakpoint

        Dim y = 0 ' set breakpoint
    End Function

    Async Function DoSomethingAsync() As Task(Of Integer)
        Await Task.Delay(1000)
        Return 5
    End Function
End Module

// Breakpoints to show control flow.
using System.Threading.Tasks;

class Program
{
    static void Main(string[] args)
    {
        Task theTask = ProcessAsync();
        int x = 0;  // set breakpoint
        theTask.Wait();
    }

    static async Task ProcessAsync()
    {
        var result = await DoSomethingAsync();  // set breakpoint

        int y = 0;  // set breakpoint
    }

    static async Task<int> DoSomethingAsync()
    {
        await Task.Delay(1000);
        return 5;
    }
}

Legen Sie Die Debughaltepunkte auf den drei Zeilen fest, die einem Kommentar "des festgelegten Haltepunkts" enden.
Wählen Sie die F5-TASTE aus, oder wählen Sie Debuggen, Debugging starten auf der Menüleiste, um die Anwendung auszuführen.

Die Anwendung wechselt in die ProcessAsync-Methode und -Unterbrechungen in der Zeile ein, die den Erwartungsoperator enthält.
Wählen Sie die F5-TASTE erneut aus.

Da die Anwendung, die auf einer Anweisung beendet wird, die einen Erwartungsoperator enthält, die Anwendung sofort die asynchrone Methode beendet und eine Aufgabe zurückgibt. Daher wird die Anwendung die ProcessAsync-Methode beendet und am Haltepunkt in der aufrufenden Methode unterbrochen (Main).
Wählen Sie die F5-TASTE erneut aus.

Wenn die Methode DoSomethingAsync abzuschließen, die Codezusammenfassungen nach der Erwartungsanweisung im Aufruf von Methoden. Daher die unterbrochen am Haltepunkt in der ProcessAsync-Methode.

Als DoSomethingAsync zunächst erwartet wurde, beendet die ProcessAsync-Methode und hat eine Aufgabe zurück. Wenn die erwartete dann abgeschlossene DoSomethingAsync-Methode, die Auswertung der Erwartungsanweisung den Rückgabewert von DoSomethingAsync erzeugt wurde. Die DoSomethingAsync-Methode wird definiert, um Task (Of Integer) in Visual Basic oder Task<int> in C# zurückzugeben, hat der Wert in der Anweisung eine ganze Zahl. Weitere Informationen finden Sie unter Asynchrone Rückgabetypen (C# und Visual Basic).

Abrufen und eine Aufgabe dann, erwartet

In der ProcessAsync-Methode ist die Anweisung Dim result = Await DoSomethingAsync() (Visual Basic) oder var result = await DoSomethingAsync(); (C#) eine Kontraktion der beiden folgenden Anweisungen:

Dim theTask = DoSomethingAsync()
Dim result = Await theTask

var theTask = DoSomethingAsync();
var result = await theTask;

Die erste Codezeile ruft die asynchrone Methode auf und gibt eine Aufgabe zurück. Diese Aufgabe wird mit dem Erwartungsoperator in der nächsten Codezeile zugeordnet. Die Erwartungsanweisung beendet die Methode (ProcessAsync) und gibt eine andere Aufgabe. Wenn die Aufgabe, die mit dem Erwartungsoperator zugeordnet ist, abgeschlossen wurde, wird Code in der Methode (ProcessAsync) nach der Erwartungsanweisung fort.

Wenn die Erwartungsanweisung sofort eine andere Aufgabe zurückgibt, ist diese Aufgabe das zurückgegebene Argument der asynchronen Methode, die den Erwartungsoperator (ProcessAsync) enthält. Die Aufgabe, die vom Erwartung zurückgegeben wird, umfasst die Codeausführung, nachdem das Erwartung in derselben Methode auftritt, die ist, warum diese Aufgabe zu der Aufgabe unterscheidet, die mit dem Erwartung zugeordnet ist.

Einzelschritt und Prozedurschritt

Der Befehl Einzelschritt tritt in eine Methode, aber der Befehl Prozedurschritt führt den Methodenaufruf und dann die Timeouts auf der nächsten Zeile des Aufrufs von Methoden aus. Weitere Informationen finden Sie unter [NIB] Übersicht über das schrittweise Ausführen von Code.

Im folgenden Verfahren wird veranschaulicht, was ausgeführt wird, wenn Sie die Einzelschritt oder Prozedurschritt Befehle an einer Erwartungsanweisung auswählen.

Ersetzen Sie den Code in der Konsolenanwendung durch den folgenden Code.

' Step Into and Step Over Example
Imports System.Threading.Tasks

Module Module1
    Sub Main()
        ProcessAsync.Wait()
    End Sub

    Async Function ProcessAsync() As Task
        Dim result = Await DoSomethingAsync()  ' Step Into or Step Over from here

        Dim y = 0
    End Function

    Async Function DoSomethingAsync() As Task(Of Integer)
        Await Task.Delay(1000)
        Return 5
    End Function
End Module

// Step Into and Step Over Example.
using System.Threading.Tasks;

class Program
{
    static void Main(string[] args)
    {
        ProcessAsync().Wait();
    }

    static async Task ProcessAsync()
    {
        var result = await DoSomethingAsync();  // Step Into or Step Over from here

        int y = 0;
    }

    static async Task<int> DoSomethingAsync()
    {
        await Task.Delay(1000);
        return 5;
    }
}

Wählen Sie die F11-Taste aus, oder wählen Sie Debuggen, Einzelschritt auf der Menüleiste, um eine Demonstration der Step Into Befehls an einer Anweisung zu beginnen, die einen Erwartungsoperator enthält.

Die Anwendung wird gestartet und -Unterbrechungen auf die erste Zeile, die Sub Main() in Visual Basic oder in der öffnenden geschweiften Klammer der Main-Methode in C# ist.
Wählen Sie die F11-Taste drei weitere Male aus.

Die Anwendung muss in der Erwartungsanweisung in der ProcessAsync-Methode jetzt sein.
Wählen Sie die F11-Taste aus.

Die Anwendung wechselt in die DoSomethingAsync-Methode und -Unterbrechungen in der ersten Zeile ein. Dieses Verhalten tritt auf, obwohl, an der await-Anweisung, die Anwendung sofort zum Aufruf von Methoden (Main) zurückgibt.
Halten Sie, die F11-Taste auszuwählen, bis die Anwendung zur Erwartungsanweisung in der ProcessAsync-Methode zurückgibt.
Wählen Sie die F11-Taste aus.

Die unterbrochen in der Zeile, die der Erwartungsanweisung folgt.
Wählen Sie auf der Menüleiste Sie Debuggen, Debuggen beenden, die Ausführung der Anwendung zu beenden.

Die nächsten Schritte zeigen den Befehl Prozedurschritt an einer Erwartungsanweisung.
Wählen Sie die F11-Taste viermal aus, oder wählen Sie Debuggen, Einzelschritt auf der Menüleiste viermal aus.

Die Anwendung muss in der Erwartungsanweisung in der ProcessAsync-Methode jetzt sein.
Wählen Sie die F10-Taste aus, oder wählen Sie Debuggen, Prozedurschritt auf der Menüleiste aus.

Ausführungs-Unterbrechungen an der Zeile, die der Erwartungsanweisung folgt. Dieses Verhalten tritt auf, wenn die Anwendung sofort zum Aufruf von Methoden (Main) an der Erwartungsanweisung zurückgibt. Der Befehl Step Over tritt auch zur Ausführung der DoSomethingAsync-Methode, wie erwartet.
Wählen Sie auf der Menüleiste Sie Debuggen, Debuggen beenden, die Ausführung der Anwendung zu beenden.

Wie die folgende Schrittshow, das Verhalten Einzelschritt und Prozedurschritt Befehle unterscheidet sich geringfügig, wenn der Erwartungsoperator auf einer anderen Zeile vom Aufruf der asynchronen Methode ist.
In der ProcessAsync-Methode ersetzen Sie die Erwartungsanweisung durch den folgenden Code. Die Vorlage erwarten Anweisung ist eine Kontraktion der beiden folgenden Anweisungen.
```
Dim theTask = DoSomethingAsync()
Dim result = Await theTask
```
```
var theTask = DoSomethingAsync();
var result = await theTask;
```
Wählen Sie die F11-Taste aus oder wählen Sie Debuggen, Einzelschritt auf der Menüleiste mehrmals, um die Ausführung zu starten und den Code schrittweise auszuführen.

Am Aufruf DoSomethingAsync, die Einzelschritt Befehls-Unterbrechungen in der DoSomethingAsync-Methode, während der Befehl Prozedurschritt zur nächsten Anweisung führt, wie erwartet. Geben Sie an der Erwartungsanweisung Unterbrechung beider Befehle mit der Anweisung, die dem Erwartung folgt.

Ausführen bis Rücksprung

In Methoden, die nicht asynchron sind, wird der Befehl Ausführen bis Rücksprung den Aufruf von Methoden im Code ein, der dem Methodenaufruf folgt. Für asynchrone Methoden hängt die Logik für, der die Ausführungs-Unterbrechungen im Aufruf von Methoden komplexer ist und diese Logik davon ab, ob der Befehl Ausführen bis Rücksprung in der ersten Zeile der asynchronen Methode ist.

Ersetzen Sie den Code in der Konsolenanwendung durch den folgenden Code.

' Step Out Example
Imports System.Threading.Tasks

Module Module1
    Sub Main()
        ProcessAsync.Wait()
    End Sub

    Async Function ProcessAsync() As Task
        Dim theTask = DoSomethingAsync()
        Dim z = 0
        Dim result = Await theTask
    End Function

    Async Function DoSomethingAsync() As Task(Of Integer)
        Debug.WriteLine("before")  ' Step Out from here
        Await Task.Delay(1000)
        Debug.WriteLine("after")
        Return 5
    End Function
End Module

// Step Out Example.
using System.Diagnostics;
using System.Threading.Tasks;

class Program
{
    static void Main(string[] args)
    {
        ProcessAsync().Wait();
    }

    static async Task ProcessAsync()
    {
        var theTask = DoSomethingAsync();
        int z = 0;
        var result = await theTask;
    }

    static async Task<int> DoSomethingAsync()
    {
        Debug.WriteLine("before");  // Step Out from here
        await Task.Delay(1000);
        Debug.WriteLine("after");
        return 5;
    }
}

Legen Sie einen Haltepunkt in der Debug.WriteLine("before") Zeile in der DoSomethingAsync-Methode fest.

Dies ist, das Verhalten des Befehls Ausführen bis Rücksprung von einer Zeile in einer asynchronen Methode zu veranschaulichen, die nicht die erste Zeile.
Wählen Sie die F5-TASTE aus oder wählen Sie Debuggen, Debugging starten auf der Menüleiste, um die Anwendung zu starten.

Die Code-Unterbrechungen auf Debug.WriteLine("before") in der DoSomethingAsync-Methode.
Wählen Sie die UMSCHALT+F11-Tasten aus, oder wählen Sie Debuggen, Ausführen bis Rücksprung auf der Menüleiste aus.

Die unterbrochen im Aufruf der Methoden an der Erwartungsanweisung für die Aufgabe, die mit der aktuellen Methode zugeordnet ist. Dadurch wird die Anwendung unterbrochen wird auf der Erwartungsanweisung in der ProcessAsync-Methode. Die Anwendung führt nicht auf Dim z = 0 (Visual Basic) oder int z = 0; (C#), die der Code ist, der dem Aufruf der DoSomethingAsync-Methode folgt.
Wählen Sie Debuggen, Debuggen beenden auf der Menüleiste, die Ausführung der Anwendung zu beenden.

Die folgenden Schritte zeigen, wie wenn Sie Ausführen bis Rücksprung aus der ersten Zeile einer asynchronen Methode geschieht.
Entfernen Sie den vorhandenen Haltepunkt, und fügen Sie einen Haltepunkt auf die erste Zeile der DoSomethingAsync-Methode hinzu.

Fügen Sie in C# den Haltepunkt auf der öffnenden geschweiften Klammer der DoSomethingAsync-Methode hinzu. In Visual Basic fügen Sie den Haltepunkt auf der Zeile hinzu, die Async Function DoSomethingAsync() As Task(Of Integer) enthält.
Wählen Sie die F5-TASTE, um die Anwendung zu starten.

Die Code-Unterbrechungen in der ersten Zeile der DoSomethingAsync-Methode.
Klicken Sie auf der Menüleiste wählen Sie Debuggen, Fenster, Ausgabe aus.

Das Ausgabefenster wird geöffnet.
Wählen Sie die UMSCHALT+F11-Tasten aus, oder wählen Sie Debuggen, Ausführen bis Rücksprung auf der Menüleiste aus.

Die Anwendungszusammenfassungen, bis die asynchrone Methode die erste erreicht, erwarten und dann die Anwendung unterbrochen wird an der aufrufenden Anweisung. Dadurch wird die unterbrochen auf Dim the Task = DoSomethingAsync() (Visual Basic) oder var theTask = DoSomethingAsync(); (C#). ", bevor" Meldung im Ausgabefenster eingeblendet wurde, aber "nach" Nachricht noch nicht aufgetreten ist.
Wählen Sie die F5-TASTE, um fortzufahren, um die Anwendung auszuführen.

Die Anwendung wird mit der Anweisung fort, die der Erwartungsanweisung in der aufgerufenen asynchronen Funktion (DoSomethingAsync) folgt. "nach" Meldung wird im Ausgabefenster.

Siehe auch

Konzepte

[NIB] Übersicht über das schrittweise Ausführen von Code

Freigeben über