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 Pierwsze spojrzenie na debuger. 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. Możesz przejść przez kod i przyjrzeć się wartościom przechowywanym w zmiennych. Możesz ustawić zegarki na zmiennych, aby zobaczyć, kiedy wartości się zmieniają, możesz sprawdzić ścieżkę wykonywania kodu, sprawdzić, czy działa gałąź kodu itd. Jeśli to ćwiczenie po raz pierwszy próbujesz debugować kod, warto przeczytać artykuł Debugowanie dla początkujących przed przejściem do tego artykułu.

Mimo że aplikacja demonstracyjna to Visual Basic, większość funkcji ma zastosowanie do języków C#, C++, F#, Python, JavaScript i innych obsługiwanych przez program Visual Studio (F# nie obsługuje edycji i kontynuowania). Języki F# i JavaScript nie obsługują okna Autos(Autos ). Zrzuty ekranu znajdują się w Visual Basic.

Ten samouczek obejmuje następujące kroki:

• Uruchom debuger i naciśnij 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 2019 i pakiet roboczy programowania dla wielu platform .NET Core.

Jeśli program Visual Studio nie został jeszcze zainstalowany, przejdź do strony pobierania programu Visual Studio, aby zainstalować ją bezpłatnie.

Jeśli musisz zainstalować obciążenie, ale masz już program Visual Studio, przejdź do pozycji Narzędzia Pobierz narzędzia>i funkcje..., co spowoduje otwarcie Instalator programu Visual Studio. Zostanie uruchomiona Instalator programu Visual Studio. Wybierz obciążenie programowanie aplikacji klasycznych platformy .NET, a następnie wybierz pozycję Modyfikuj.

Tworzenie projektu

Najpierw należy utworzyć projekt aplikacji konsolowej platformy .NET Core. Typ projektu jest dostarczany ze wszystkimi potrzebnymi plikami szablonów, zanim jeszcze wszystko zostało dodane.

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

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

3. W oknie Tworzenie nowego projektu wprowadź konsolę w polu wyszukiwania. 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

   Jeśli nie widzisz szablonu Aplikacja konsolowa, możesz zainstalować go w oknie Tworzenie nowego projektu . W komunikacie Nie można znaleźć tego, czego szukasz? wybierz link Zainstaluj więcej narzędzi i funkcji. Następnie w Instalator programu Visual Studio wybierz obciążenie programowanie aplikacji klasycznych platformy .NET.

4. W oknie Konfigurowanie nowego projektu wprowadź polecenie get-started-debug w polu Nazwa projektu. Następnie wybierz Dalej.

5. W oknie Dodatkowe informacje upewnij się, że w menu rozwijanym Framework wybrano pozycję .NET 8.0, a następnie wybierz pozycję Utwórz.

Program Visual Studio otwiera nowy projekt.

Tworzenie aplikacji

W pliku Program.vb zastąp zamiast tego 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 klawisz F5 (Debuguj > rozpocznij debugowanie) lub wybierz zielony przycisk Rozpocznij debugowanie na pasku narzędzi debugowania.

   

   Klawisz F5 uruchamia aplikację z debugerem dołączonym do procesu aplikacji, ale teraz nie zrobiliśmy nic specjalnego 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 klawisz (Shift + F5) lub wybierz czerwony przycisk Zatrzymaj debugowanie na pasku narzędzi debugowania.

   

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

Ustawianie punktu przerwania i uruchamianie debugera

1. For W pętli Main funkcji ustaw punkt przerwania, klikając lewy margines w 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 powinien zawiesić uruchomiony kod, aby można było przyjrzeć się wartościom zmiennych lub zachowaniu pamięci, czy też czy jest uruchamiana 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 do wiersza 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 instrukcja nie jest jeszcze wykonywana).

   Jeśli aplikacja nie jest jeszcze uruchomiona, klawisz F5 uruchamia debuger i zatrzymuje się w pierwszym punkcie przerwania. W przeciwnym razie klawisz F5 kontynuuje uruchamianie aplikacji w następnym punkcie 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, które można ustawić, takich jak warunkowe punkty przerwania, zobacz Używanie punktów przerwania.

Nawigowanie po kodzie w debugerze przy użyciu poleceń kroków

W tym artykule używamy skrótów klawiaturowych, ponieważ jest to dobry sposób na szybkie wykonywanie aplikacji w debugerze (równoważne polecenia, takie jak polecenia menu, są wyświetlane w nawiasach).

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

   Po dwukrotnym naciśnięciu klawisza F11 powinien znajdować się w tym wierszu kodu:

   SendMessage(name, a(i))

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

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

   

   F11 jest poleceniem Step Into i rozwija wykonywanie aplikacji po jednej instrukcji naraz. F11 to dobry sposób na sprawdzenie przepływu wykonywania w najbardziej szczegółowy sposób. (Aby przyspieszyć przechodzenie przez kod, pokażemy również inne opcje). Domyślnie debuger pomija kod nieużytkownika (jeśli chcesz uzyskać więcej szczegółów, zobacz Tylko mój kod).

   Załóżmy, że zakończono badanie SendMessage metody i chcesz wydostać się z metody, ale pozostać w debugerze. Można to zrobić za pomocą polecenia Krok do wyjścia .

3. Naciśnij klawisze Shift + F11 (lub debuguj).>

   To polecenie wznawia wykonywanie aplikacji (i przechodzi do debugera), dopóki bieżąca metoda lub funkcja nie zostanie zwrócona.

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

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

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

   

   Zauważ, że tym razem debuger nie przechodzi do SendMessage metody . Klawisz F10 rozwija debuger bez przechodzenia do funkcji lub metod w kodzie aplikacji (kod nadal jest wykonywany). Naciskając klawisz F10 na SendMessage wywołaniu metody (zamiast F11), pominięto kod SendMessage implementacji dla elementu (co może nie być teraz interesujące). Aby uzyskać więcej informacji na temat różnych sposobów przechodzenia przez kod, zobacz Navigate code in the debugger (Nawigowanie po kodzie w debugerze).

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

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

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

   

3. Wybierz przycisk Uruchom, aby kliknąć.

   Debuger przechodzi do Console.WriteLine metody .

   Użycie tego przycisku jest podobne do ustawiania tymczasowego punktu przerwania. Polecenie Run to Click jest przydatne, aby szybko obejść się w widocznym regionie kodu aplikacji (możesz wybrać dowolny otwarty plik).

Szybkie ponowne uruchamianie aplikacji

Aby ponownie uruchomić aplikację, naciśnij kombinację klawiszy Ctrl + Shift + F5, oszczędza czas w porównaniu z zatrzymywaniem aplikacji i ponownym uruchamianiem debugera. Debuger wstrzymuje się w pierwszym punkcie przerwania, który zostanie trafiony przez wykonanie kodu.

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

Sprawdzanie zmiennych za pomocą porad dotyczących danych

Funkcje, które umożliwiają inspekcję zmiennych, są jedną z najbardziej przydatnych funkcji debugera i istnieją różne sposoby, aby to zrobić. 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 letters zmiennej i zobaczysz jej wartość domyślną, wartość pierwszego elementu w tablicy, "f"c.

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

3. Naciśnij klawisz F5 (lub Kontynuuj debugowanie>) kilka razy, aby iterować kilka razy przez For 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ę For pętli, pokazując wartości f, a następnie fr, i fretak dalej.

   Często podczas debugowania chcesz szybko sprawdzić wartości właściwości w zmiennych, aby sprawdzić, czy przechowują one wartości, które mają być przechowywane, a porady dotyczące danych są dobrym sposobem 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 (Autos ) są wyświetlane wszystkie zmienne używane w bieżącym wierszu lub w 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 Ustawienia lokalne 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 zegarek dla zmiennej name , przejdź przez kod, aby zobaczyć wartość name zmiany zmiennej z każdą for iteracją pętli.

   W przeciwieństwie do innych okien zmiennych, okno Obserwowanie zawsze wyświetla 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 Watch variables with Watch windows (Obserwowanie zmiennych za pomocą okien kontrolnych).

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ń systemu Windows.>

2. Wybierz klawisz F11 kilka razy, aż zobaczysz wstrzymanie debugera w metodzie SendMessage . Zapoznaj się z oknem stosu wywołań .

   

   W oknie Stos wywołań jest wyświetlana kolejność wywoływania metod i funkcji. W górnym wierszu jest wyświetlana bieżąca funkcja ( SendMessage metoda w tej aplikacji). Drugi wiersz pokazuje, że SendMessage został wywołany z Main metody itd.

   Uwaga

   Okno Stos wywołań jest podobne do perspektywy debugowania w niektórych środowiskach IDE, takich jak Eclipse.

   Stos wywołań to dobry sposób na sprawdzenie i zrozumienie przepływu wykonywania aplikacji.

   Możesz kliknąć dwukrotnie wiersz kodu, aby przyjrzeć się temu kodowi źródłowemu, a także zmienić bieżący zakres w ramach inspekcji przez debuger. Ta akcja nie powoduje postępu debugera.

   Możesz również użyć menu prawym przyciskiem myszy w oknie Stos 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ń).

Zmienianie przepływu wykonywania

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

2. W przypadku wstrzymania debugera w SendMessage wywołaniu metody użyj myszy, aby chwycić żółtą strzałkę lub wskaźnik wykonywania (na lewym marginesie) i przeciągnij wskaźnik w górę do instrukcji Console.WriteLine .

3. Naciśnij klawisz F11.

   Debuger ponownie uruchamia metodę Console.WriteLine (ta akcja jest widoczna w danych wyjściowych okna konsoli).

   Zmieniając przepływ wykonywania, można wykonywać takie czynności, jak testowanie różnych ścieżek wykonywania kodu lub ponowne uruchamianie kodu bez ponownego uruchamiania debugera.

   Ostrzeżenie

   Często należy zachować ostrożność przy użyciu tej funkcji i zobaczyć ostrzeżenie w etykietce narzędzia. 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 klawisz F5 , aby kontynuować uruchamianie aplikacji.

   Gratulujemy ukończenia tego samouczka!

Następne kroki

W tym samouczku przedstawiono sposób uruchamiania debugera, przechodzenia przez kod i inspekcji zmiennych. Warto zapoznać się z ogólnymi funkcjami debugera wraz z linkami do dodatkowych informacji.

Pierwsze spojrzenie na debugera