共用方式為


逐步解說:搭配非同步方法使用偵錯工具

您可以使用非同步功能,您可以呼叫非同步方法,而不需使用回呼或分割您的多個方法或 Lambda 運算式的程式碼。 若要使程式碼非同步,您呼叫非同步方法而非使用同步方法並加入一些關鍵字加入程式碼。 如需詳細資訊,請參閱使用 Async 和 Await 設計非同步程式 (C# 和 Visual Basic)

在 Visual Studio 偵錯工具,您可以使用 [逐步執行]、 [步驟] 和 [步驟] 命令與 Async 功能。 您也可以繼續使用中斷點,特別是檢視包含 Await 運算子的陳述式的控制流程。 在這個逐步解說中,您將完成下列工作,您可以依任何順序執行。

  • 示範在等候陳述式的控制流程使用中斷點。

  • 了解 [逐步執行] 和 [步驟] 命令的行為在包含 Await 運算子的陳述式。

  • 因此,使用它從非同步方法的內部時,所發生的 [步驟] 命令的行為。

顯示控制流程的中斷點

如果您將標記為已使用 Async (Visual Basic) 或 (C#) 非同步 修飾詞的方法,在方法中使用 等候 (Visual Basic) 或 等候 (C#) 運算子。 若要建立等候運算式,您使 Await 運算子與工作。 當等候運算式工作時,會呼叫目前的方法會立即完成並傳回不同的工作。 當與 Await 運算子時的工作完成,執行在相同方法繼續。 如需詳細資訊,請參閱非同步程式中的控制流程 (C# 和 Visual Basic)

注意事項注意事項

非同步方法傳回給呼叫端時,可能會遇到不完整時或是在非同步方法的結尾先等候的物件,最先出現。

注意事項注意事項

在這些範例中的主控台應用程式使用 Wait 方法可防止應用程式終止的 Main。因為死結情況可能發生,您不應該使用 Wait 方法在主控台應用程式外。

示範發生了什麼的下列程序中設定中斷點,當應用程式執行等候陳述式。 您也可以將示範控制流程將 Debug.WriteLine 陳述式。

  1. 建立主控台應用程式,然後將下列程式碼貼入其中:

    ' 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;
        }
    }
    
  2. 設定以「設定中斷點」註解結束三行的偵錯中斷點。

  3. 選擇 F5 鍵或選取 [偵錯],請在功能表列上的 [啟動偵錯] 執行應用程式。

    應用程式在包含 Await 運算子的行進入 ProcessAsync 方法而中斷。

  4. 再次選擇 F5 鍵。

    由於應用程式中包含 Await 運算子的陳述式停止,應用程式會立即結束非同步方法並傳回工作。 因此,應用程式就會結束 ProcessAsync 方法而中斷。在呼叫的方法 (Main) 的中斷點。

  5. 再次選擇 F5 鍵。

    在 DoSomethingAsync 方法完成時,程式碼會在呼叫方法的等候陳述式之後繼續。 因此,應用程式中斷在 ProcessAsync 方法中的中斷點。

    當 DoSomethingAsync 最初等候, ProcessAsync 方法會結束並傳回工作。 當等候的 DoSomethingAsync 方法會完成,等候陳述式的評估產生傳回值 DoSomethingAsync。 DoSomethingAsync 方法在 C# 中定義傳回在 Visual Basic 中的 Task (Of Integer)Task<int> ,因此,在其傳回陳述式的值是整數。 如需詳細資訊,請參閱非同步方法的傳回型別 (C# and Visual Basic)

JJ155813.collapse_all(zh-tw,VS.110).gif取得然後等候工作

在 ProcessAsync 方法中,陳述式 Dim result = Await DoSomethingAsync() (Visual Basic) 或 var result = await DoSomethingAsync(); (C#) 為下列兩個陳述式的縮小:

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

第一個程式碼會呼叫非同步方法並傳回工作。 該工作與下一行程式碼的 Await 運算子。 等候陳述式結束方法 (ProcessAsync) 和傳回不同的工作。 當與 Await 運算子時的工作完成時,程式碼在方法 (ProcessAsync) 繼續等候陳述式之後。

當等候陳述式立即傳回不同的工作時,該工作是包含 Await 運算子的非同步方法傳回的引數 (ProcessAsync)。 由等候傳回這些工作時,會發生在相同方法之後的等候,是的程式碼執行該工作為何與等候的工作不同。

逐步執行並逐步執行

[逐步執行] 命令逐步執行方法,不過, [步驟] 命令會呼叫方法的下一行執行方法呼叫然後中斷。 如需詳細資訊,請參閱[NIB] 程式碼逐步執行概觀

下列程序顯示出現,當您選取 [逐步執行] 或 [步驟] 命令在等候陳述式。

  1. 以下列程式碼取代在主控台應用程式的程式碼。

    ' 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;
        }
    }
    
  2. 選擇 F11 鍵或選取 [偵錯],請在功能表列上的 [逐步執行] 開始 Step Into 命令的示範含有 Await 運算子的陳述式。

    應用程式在第一行開始並中斷,是在 Visual Basic 或 Main 方法左大括號的 C# 中的 Sub Main() 。

  3. 選擇 F11 鍵三倍。

    應用程式應該會在 ProcessAsync 方法的等候陳述式。

  4. 選擇 F11 鍵。

    應用程式在第一行輸入 DoSomethingAsync 方法而中斷。 這種行為的發生,即使,而在 await 陳述式中,應用程式會立即回到呼叫的方法 (Main)。

  5. 選取到應用程式的 Keep F11 鍵回 ProcessAsync 方法等候的陳述式。

  6. 選擇 F11 鍵。

    應用程式必須在等候陳述式的分行符號。

  7. 在功能表列上,選擇 [偵錯]],則 [停止偵錯] 停止執行。

    下列步驟示範 [步驟] 命令在等候陳述式。

  8. 選擇 F11 鍵四次或選取 [偵錯],請在功能表列上的 [逐步執行] 四次。

    應用程式應該會在 ProcessAsync 方法的等候陳述式。

  9. 選擇 F10 鍵或選取 [偵錯],請在功能表列上的 [步驟] 。

    執行中斷之後等候陳述式的行。 這種行為的發生,即使應用程式立即傳回給呼叫的方法 (Main) 在等候陳述式。 Step Over 命令也不進入 DoSomethingAsync 方法的執行,如預期般運作。

  10. 在功能表列上,選擇 [偵錯]],則 [停止偵錯] 停止執行。

    在下列步驟中,會顯示 [逐步執行] 和 [步驟] 命令的行為稍有不同,因為 Await 運算子是在從呼叫中不同的行至非同步方法時。

  11. 在 ProcessAsync 方法中,以下列程式碼取代等候陳述式。 原始等候陳述式是下列兩個陳述式的合約。

    Dim theTask = DoSomethingAsync()
    Dim result = Await theTask
    
    var theTask = DoSomethingAsync();
    var result = await theTask;
    
  12. 選擇 F11 鍵或選取 [偵錯],請在功能表列上多次的 [逐步執行] 至程式碼開始執行和步驟。

    在對 DoSomethingAsync的呼叫, [ [逐步執行] 命令在 DoSomethingAsync 方法中),,而 [步驟] 命令移至下一個陳述式,如預期般運作。 在等候陳述式,兩個命令中斷之後等候的陳述式。

跳離函式

在不是的非同步方法, [步驟] 命令會在之後呼叫方法的程式碼呼叫的方法中斷。 如需非同步方法,執行在呼叫的方法中斷的邏輯較為複雜和該邏輯取決於 [步驟] 命令是否在非同步方法的第一行。

  1. 以下列程式碼取代在主控台應用程式的程式碼。

    ' 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;
        }
    }
    
  2. 設定 Debug.WriteLine("before") 行設定中斷點在 DoSomethingAsync 方法。

    這是為了示範 [步驟] 命令的行為從一行中不是第一行的非同步方法。

  3. 選擇 F5 鍵或選取 [偵錯],請在功能表列上的 [啟動偵錯] 啟動應用程式。

    程式碼會在 DoSomethingAsync 方法的 Debug.WriteLine("before") 中斷。

  4. 選取 Shift+F11 鍵或選取 [偵錯],請在功能表列上的 [步驟] 。

    應用程式在呼叫的方法會中斷與目前方法的工作等候陳述式。 因此,應用程式會在 ProcessAsync 方法中等候陳述式內容中斷。 應用程式在 Dim z = 0 (Visual Basic) 或 int z = 0; (C#) 中斷,為程式碼之後呼叫 DoSomethingAsync 方法。

  5. 選取 [偵錯],請在功能表列上的 [停止偵錯] 停止執行。

    下列步驟示範發生的事情,當您從非同步方法的第一行中的 [步驟] 。

  6. 移除現有的中斷點,然後在 DoSomethingAsync 方法的第一行設定中斷點。

    在 C# 中,將在 DoSomethingAsync 方法的左邊大括號的中斷點。 在 Visual Basic 中,將該行的中斷點會包含 Async Function DoSomethingAsync() As Task(Of Integer)。

  7. 選擇 F5 鍵啟動應用程式。

    程式碼在 DoSomethingAsync 方法的第一個分行符號。

  8. 在功能表列上,選擇 [偵錯]],則 [視窗], [輸出]。

    [輸出] 視窗隨即開啟。

  9. 選取 Shift+F11 鍵或選取 [偵錯],請在功能表列上的 [步驟] 。

    應用程式繼續執行,直到非同步方法到達第一個等候,應用程式會中斷在後面的陳述式。 因此,應用程式在 Dim the Task = DoSomethingAsync() (Visual Basic) 或 var theTask = DoSomethingAsync(); (C#) 中斷。 「,」訊息會顯示在輸出視窗之前,不過, 「,」訊息不會出現。

  10. 選擇 F5 鍵繼續執行應用程式。

    應用程式會繼續依照非同步呼叫的函式中的陳述式 (DoSomethingAsync) 的等候陳述式。 < 在訊息之後出現在輸出視窗中。

請參閱

概念

[NIB] 程式碼逐步執行概觀