Samouczek: dowiedz się, jak debugować kod Visual Basic przy użyciu programu Visual Studio

W tym artykule przedstawiono funkcje debugera programu Visual Studio w przewodniku krok po kroku. Jeśli chcesz wyświetlić funkcje debugera wyższego poziomu, zobacz Omówienie debugera programu Visual Studio. Podczas debugowania aplikacji zwykle oznacza to, że uruchamiasz aplikację z dołączonym debugerem. Podczas wykonywania tego zadania debuger udostępnia wiele sposobów, aby zobaczyć, co robi kod podczas jego działania.

• Przejrzyj kod i przyjrzyj się wartościom przechowywanym w zmiennych.
• Ustaw zegarki na zmiennych, aby zobaczyć, kiedy wartości się zmieniają.
• Sprawdź ścieżkę wykonywania kodu, aby sprawdzić, czy działa gałąź kodu.

Jeśli to ćwiczenie jest pierwszym razem, gdy próbowano debugować kod, warto przeczytać artykuł Debugowanie dla początkujących.

Mimo że aplikacja demonstracyjna w tym artykule korzysta z języka Visual Basic, większość funkcji dotyczy języków C#, C++, F#, Python, JavaScript i innych języków obsługiwanych przez program Visual Studio. Język F# nie obsługuje funkcji Edytuj i kontynuuj. Języki F# i JavaScript nie obsługują okna Autos . Zrzuty ekranu znajdują się w Visual Basic.

W tym samouczku nauczysz się następujących rzeczy:

• Uruchom debuger i napotkaj punkty przerwania
• Learn commands to step through code in the debugger (Instrukcje dotyczące wykonywania kroków w kodzie w debugerze)
• Sprawdzanie zmiennych w poradach dotyczących danych i oknach debugera
• Badanie stosu wywołań

Wymagania wstępne

Musisz mieć zainstalowany program Visual Studio, w tym pakiet roboczy programowania dla wielu platform .NET Core .

• Jeśli musisz zainstalować program Visual Studio, aby uzyskać bezpłatną wersję, zobacz Pliki do pobrania programu Visual Studio.
• Jeśli musisz zainstalować obciążenie, ale masz już program Visual Studio, przejdź do pozycji NarzędziaPobierz narzędzia >i funkcje..., co spowoduje otwarcie Instalatora programu Visual Studio. Wybierz obciążenie programowanie aplikacji .NET na komputerach stacjonarnych, a następnie wybierz Modyfikuj.

Tworzenie projektu

Najpierw utwórz projekt aplikacji konsolowej platformy .NET Core. Typ projektu jest dostarczany ze wszystkimi potrzebnymi plikami szablonów, zanim cokolwiek dodasz!

1. Otwórz program Visual Studio. Jeśli okno uruchamiania nie jest otwarte, wybierz Plik>Okno uruchamiania.

2. W oknie uruchamiania wybierz pozycję Utwórz nowy projekt.

3. W oknie Tworzenie nowego projektu w polu wyszukiwania wprowadź konsolę. Następnie wybierz pozycję Visual Basic z listy Język, a następnie wybierz pozycję Windows z listy Platforma.

   Po zastosowaniu filtrów języka i platformy wybierz szablon Aplikacja konsolowa dla platformy .NET Core, a następnie wybierz przycisk Dalej.

   

   Uwaga / Notatka

   Jeśli nie widzisz szablonu Console App, możesz zainstalować go w oknie Create a new project (Tworzenie nowego projektu). W komunikacie Nie można znaleźć tego, czego szukasz? wybierz link Zainstaluj więcej narzędzi i funkcji . Następnie w Instalatorze programu Visual Studio wybierz pakiet programowanie aplikacji na platformie .NET na komputery stacjonarne.

4. W oknie Konfigurowanie nowego projektu dla Nazwa projektu wpisz get-started-debugging. Następnie wybierz Dalej.

5. W oknie Dodatkowe informacje upewnij się, że dla programu Framework wybrano pozycję .NET 10.0, a następnie wybierz pozycję Utwórz.

Program Visual Studio otwiera nowy projekt.

Tworzenie aplikacji

W Program.vb zastąp cały kod domyślny następującym kodem:

Imports System

Class ArrayExample
  Public Shared Sub Main()
    Dim letters As Char() = {"f"c, "r"c, "e"c, "d"c, " "c, "s"c, "m"c, "i"c, "t"c, "h"c}
    Dim name As String = ""
    Dim a As Integer() = New Integer(9) {}

    For i As Integer = 0 To letters.Length - 1
      name += letters(i)
      a(i) = i + 1
      SendMessage(name, a(i))
    Next

    Console.ReadKey()
  End Sub

  Private Shared Sub SendMessage(ByVal name As String, ByVal msg As Integer)
    Console.WriteLine("Hello, " & name & "! Count to " & msg)
  End Sub
End Class

Uruchom debuger!

1. Naciśnij F5 (Debuguj > rozpocznij debugowanie) lub wybierz zielony przycisk Rozpocznij debugowanie na pasku narzędzi debugowania.

   

   F5 uruchamia aplikację z debugerem dołączonym do procesu aplikacji. Do tej pory nie wykonano żadnych specjalnych czynności w celu zbadania kodu. Aplikacja zostanie załadowana i zobaczysz dane wyjściowe konsoli.

   Hello, f! Count to 1
   Hello, fr! Count to 2
   Hello, fre! Count to 3
   Hello, fred! Count to 4
   Hello, fred ! Count to 5
   Hello, fred s! Count to 6
   Hello, fred sm! Count to 7
   Hello, fred smi! Count to 8
   Hello, fred smit! Count to 9
   Hello, fred smith! Count to 10
   

   W tym samouczku przyjrzysz się bliżej tej aplikacji przy użyciu debugera i zapoznasz się z funkcjami debugera.

2. Zatrzymaj debuger, naciskając (Shift + F5) lub wybierz czerwony przycisk Zatrzymaj debugowanie na pasku narzędzi debugowania.

   

3. W oknie konsoli naciśnij, aby zamknąć okno konsoli.

Ustawianie punktu przerwania i uruchamianie debugera

1. For W pętli funkcji Main, ustaw punkt przerwania, klikając w lewym marginesie przy następującym wierszu kodu:

   name += letters(i)

   Zostanie wyświetlone czerwone kółko, w którym ustawiono punkt przerwania.

   Punkty przerwania są jedną z najbardziej podstawowych i podstawowych funkcji niezawodnego debugowania. Punkt przerwania wskazuje, gdzie program Visual Studio zawiesza uruchomiony kod. Podczas wstrzymania można przyjrzeć się wartościom zmiennych lub zachowaniu pamięci. Możesz sprawdzić, czy działa gałąź kodu.

2. Naciśnij klawisz F5 (Debuguj > rozpocznij debugowanie) lub przycisk Rozpocznij debugowanie na pasku narzędzi debugowania. Aplikacja zostanie uruchomiona, a debuger zostanie uruchomiony w wierszu kodu, w którym ustawiono punkt przerwania.

   

   Żółta strzałka reprezentuje instrukcję, na której wstrzymano debuger, który również zawiesza wykonywanie aplikacji w tym samym momencie. Ta komenda nie została jeszcze wykonana.

   Jeśli aplikacja nie jest jeszcze uruchomiona, F5 uruchamia debuger i zatrzymuje się w pierwszym punkcie przerwania. W przeciwnym razie F5 kontynuuje uruchamianie aplikacji do następnego punktu przerwania.

   Punkty przerwania to przydatna funkcja, gdy znasz wiersz kodu lub sekcję kodu, którą chcesz szczegółowo zbadać. Aby uzyskać informacje na temat różnych typów punktów przerwania, zobacz Używanie punktów przerwania.

Nawiguj po kodzie w debugerze za pomocą poleceń krokowych

W tym artykule użyto skrótów klawiaturowych, ponieważ jest to dobry sposób na szybkie wykonywanie aplikacji w debugerze. Wyświetla równoważne polecenia, takie jak polecenia menu, w nawiasach.

1. Podczas gdy wykonywanie kodu jest wstrzymane w pętli w For metodzie Main, naciśnij F11 (lub wybierz pozycję Debuguj > Krok w głąb) dwukrotnie, aby przejść do SendMessage wywołania metody.

   Po dwukrotnym naciśnięciu F11 powinieneś znajdować się w tym wierszu kodu.

   SendMessage(name, a(i))

2. Naciśnij F11 jeszcze raz, aby przejść do SendMessage metody .

   Żółty wskaźnik przechodzi do SendMessage metody .

   

   F11 jest poleceniem Wejdź. Przesuwa wykonanie aplikacji o jedną instrukcję naraz. F11 to dobry sposób na sprawdzenie przepływu sterowania w największych detalach. Domyślnie debuger pomija kod nieużytkownika. Aby uzyskać więcej informacji, zobacz Just My Code.

   Załóżmy, że zakończono badanie metody SendMessage i chcesz opuścić metodę, ale pozostać w debuggerze. Można to zrobić za pomocą polecenia Wyjdź.

3. Naciśnij Shift + F11 (lub Debuguj > Step Out).

   To polecenie wznawia wykonywanie aplikacji i kontynuuje działanie debugera, dopóki bieżąca metoda lub funkcja się nie zakończy i nie zwróci wyniku.

   Należy wrócić do pętli For w metodzie Main, zatrzymując się przy wywołaniu metody SendMessage.

4. Naciśnij F11 kilka razy, aż znowu wrócisz do wywołania metody SendMessage.

5. Podczas gdy wykonywanie kodu jest wstrzymane przy wywołaniu metody, naciśnij F10 (lub wybierz pozycję Debuguj > krok powyżej).

   

   Tym razem debuger nie przechodzi do SendMessage metody . Klawisz F10 kontynuuje działanie debugera bez wchodzenia do funkcji lub metod w kodzie aplikacji. Kod nadal jest wykonywany. Naciskając klawisz F10 w wywołaniu SendMessage metody zamiast F11, pominięto kod implementacji dla elementu SendMessage. Aby uzyskać więcej informacji na temat różnych sposobów przechodzenia przez kod, zobacz Nawigacja po kodzie w debugerze.

Nawigowanie po kodzie przy użyciu polecenia Uruchom do kliknięcia

1. Naciśnij F5 , aby ponownie przejść do punktu przerwania.

2. W edytorze kodu przewiń w dół i umieść kursor na metodzie Console.WriteLine w metodzie SendMessage, aż pojawi się zielony przycisk Uruchom przez kliknięcie. Etykietka narzędzia przycisku zawiera polecenie Uruchom wykonanie tutaj.

   

3. Wybierz przycisk Uruchom, aby kliknąć .

   Debugger przechodzi do metody Console.WriteLine.

   Użycie tego przycisku jest podobne do ustawiania tymczasowego punktu przerwania. Polecenie Run to Click jest przydatne do szybkiego poruszania się po widocznej części fragmentu kodu aplikacji, którą można wybrać w dowolnym otwartym pliku.

Szybkie ponowne uruchamianie aplikacji

Aby ponownie uruchomić aplikację, naciśnij kombinację klawiszy Ctrl + Shift + F5 . Pozwala zaoszczędzić czas w porównaniu do zatrzymywania aplikacji i ponownego uruchamiania debugera. Debugger zatrzymuje się na pierwszym punkcie przerwania, który zostanie osiągnięty przez wykonujący się kod.

Debuger zatrzymuje się ponownie w punkcie przerwania ustawionym wcześniej wewnątrz For pętli.

Inspektuj zmienne za pomocą wskazówek dotyczących danych

Debuger zawiera funkcje, które umożliwiają inspekcję zmiennych. Istnieją różne sposoby inspekcji zmiennych. Często podczas próby debugowania problemu próbujesz dowiedzieć się, czy zmienne przechowują wartości, które mają być przechowywane w określonym czasie.

1. Podczas gdy wykonywanie kodu jest wstrzymane na instrukcji name += letters[i] , umieść kursor na zmiennej letters . Zostanie wyświetlona jego wartość domyślna, wartość pierwszego elementu w tablicy . "f"c

2. Następnie umieść kursor na zmiennej name , aby zobaczyć jego bieżącą wartość, pusty ciąg.

3. Naciśnij F5 (lub Kontynuuj debugowanie>) kilka razy, aby iterować kilka razy przezFor pętlę, wstrzymując ponownie w punkcie przerwania i umieszczając wskaźnik myszy na name zmiennej za każdym razem, aby sprawdzić jego wartość.

   

   Wartość zmiennej zmienia się wraz z każdą iterację pętli For, pokazując wartości f, a następnie fr, a następnie freitd.

   Często podczas debugowania kodu chcesz szybko sprawdzić wartości właściwości w zmiennych, aby sprawdzić, czy przechowują one wartości, które mają być przechowywane. Porady dotyczące danych to dobry sposób na to.

Sprawdzanie zmiennych za pomocą okien Autos i Locals

1. Zapoznaj się z oknem Autos w dolnej części edytora kodu.

   Jeśli jest zamknięty, otwórz go, gdy wykonywanie kodu jest wstrzymane w debugerze, wybierając pozycję Debuguj>autos windows>.

   W oknie Autos zobaczysz zmienne i ich bieżącą wartość. W oknie Autos są wyświetlane wszystkie zmienne używane w bieżącym lub poprzednim wierszu. Sprawdź dokumentację pod kątem zachowania specyficznego dla języka.

2. Następnie przyjrzyj się oknie Ustawienia lokalne na karcie obok okna Autos .

3. Rozwiń zmienną, letters aby wyświetlić zawarte w niej elementy.

   

   W oknie Locals są wyświetlane zmienne, które znajdują się w bieżącym zakresie , czyli bieżącym kontekście wykonywania.

Ustawianie zegarka

Możesz określić zmienną lub wyrażenie, na które chcesz mieć oko podczas przechodzenia przez kod — dodając ją do okna Obserwowanie .

1. Podczas wstrzymania debugera kliknij prawym przyciskiem myszy zmienną name i wybierz polecenie Dodaj zegarek.

   Domyślnie w dolnej części edytora kodu zostanie otwarte okno Obserwowanie .

2. Teraz, gdy ustawisz monitorowanie zmiennej name, przejdź przez kod, aby zobaczyć, jak wartość zmiennej name zmienia się z każdą iteracją pętli for.

   W przeciwieństwie do innych okien zmiennych, w oknie Watch zawsze są wyświetlane zmienne, które obserwujesz. Zmienne, które są poza zakresem, są wyświetlane jako niedostępne.

Aby uzyskać więcej informacji na temat okna Watch, zobacz Obserwowanie zmiennych za pomocą okien Watch.

Badanie stosu wywołań

1. Podczas gdy wykonywanie kodu jest wstrzymane w For pętli, wybierz okno stosu wywołań , które jest domyślnie otwarte w prawym dolnym okienku.

   Jeśli jest zamknięty, otwórz go, gdy wykonywanie kodu jest wstrzymane w debugerze, wybierając pozycję Debuguj>stos wywołań>.

2. Wybierz F11 kilka razy, aż zobaczysz wstrzymanie debugera w metodzie SendMessage . Spójrz na okno stosu wywołań.

   

   Okno Stosu Wywołań pokazuje kolejność, w jakiej są wywoływane metody i funkcje. Górny wiersz przedstawia bieżącą funkcję. W tym przykładzie jest to metoda SendMessage. Drugi wiersz pokazuje, że SendMessage został wywołany z Main metody itd.

   Uwaga / Notatka

   Okno Stos wywołań jest podobne do perspektywy debugowania w niektórych narzędziach programistycznych, takich jak Eclipse.

   Stos wywołań jest dobrym sposobem na sprawdzenie i zrozumienie przebiegu wykonania aplikacji.

   Możesz dwukrotnie kliknąć wiersz kodu, aby przejść do tego kodu źródłowego, co również zmienia bieżący zakres inspekcji przez debuger. Ta akcja nie powoduje postępu debugera.

   Możesz również użyć menu wywoływanego prawym przyciskiem myszy z okna stosu wywołań , aby wykonać inne czynności. Można na przykład wstawić punkty przerwania do określonych funkcji, przejść do debugera przy użyciu polecenia Uruchom do kursora i przejść do kodu źródłowego. Aby uzyskać więcej informacji, zobacz How to: Examine the Call Stack (Instrukcje: badanie stosu wywołań).

Zmień przepływ wykonywania

1. Naciśnij F11 dwa razy, aby uruchomić metodę Console.WriteLine .

2. Po zatrzymaniu debugera na wywołaniu metody SendMessage, użyj myszy, aby chwycić żółtą strzałkę lub wskaźnik wykonania znajdujący się na lewym marginesie, a następnie przeciągnij wskaźnik linię w górę do instrukcji Console.WriteLine.

3. Naciśnij F11.

   Debuger ponownie uruchamia metodę Console.WriteLine . Widzisz tę akcję w danych wyjściowych okna konsoli.

   Zmieniając przepływ wykonywania, można przetestować różne ścieżki wykonywania kodu lub ponownie uruchomić kod bez ponownego uruchamiania debugera.

   Ostrzeżenie

   Często należy zachować ostrożność przy użyciu tej funkcji. W etykietce narzędzia jest wyświetlane ostrzeżenie. Mogą też zostać wyświetlone inne ostrzeżenia. Przeniesienie wskaźnika nie może przywrócić aplikacji do wcześniejszego stanu aplikacji.

4. Naciśnij F5 , aby kontynuować uruchamianie aplikacji.

   Gratulujemy ukończenia tego samouczka!

Treści powiązane

W tym samouczku nauczyłeś się, jak uruchomić debuger, przechodzić przez kod i badać zmienne. Warto zapoznać się z ogólnymi funkcjami debugera wraz z linkami do dodatkowych informacji.

Omówienie debugera programu Visual Studio