Samouczek: dowiedz się, jak debugować kod w języku C# 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 jest językiem C#, większość funkcji ma zastosowanie do języków C++, Visual Basic, 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 języku C#.

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 2022 i pakiet roboczy programowanie aplikacji klasycznych platformy .NET.

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

Jeśli masz już program Visual Studio, ale nie zainstalowano obciążenia programistycznego dla komputerów .NET, przejdź do pozycji Narzędzia Pobierz narzędzia>i funkcje..., co spowoduje uruchomienie Instalator programu Visual Studio. W Instalator programu Visual Studio wybierz obciążenie programowanie aplikacji klasycznych .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ę C# 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, 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ź getStartedDebugging 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.cs zastąp cały kod domyślny następującym kodem:

using System;

class ArrayExample
{
   static void Main()
   {
      char[] letters = { 'f', 'r', 'e', 'd', ' ', 's', 'm', 'i', 't', 'h'};
      string name = "";
      int[] a = new int[10];
      for (int i = 0; i < letters.Length; i++)
      {
         name += letters[i];
         a[i] = i + 1;
         SendMessage(name, a[i]);
      }
      Console.ReadKey();
   }

   static void SendMessage(string name, int msg)
   {
      Console.WriteLine("Hello, " + name + "! Count to " + msg);
   }
}

Uruchom debuger!

W większości przypadków używamy tutaj skrótów klawiaturowych, ponieważ jest to szybki sposób wykonywania poleceń debugera. Zanotowane są również równoważne polecenia, takie jak polecenia paska narzędzi lub menu.

1. Aby uruchomić debuger, wybierz klawisz F5 lub wybierz przycisk Debuguj element docelowy na pasku narzędzi Standardowy lub wybierz przycisk Rozpocznij debugowanie na pasku narzędzi Debuguj lub wybierz pozycję Debuguj>rozpocznij debugowanie na pasku menu.

   

   Klawisz F5 uruchamia aplikację z debugerem dołączonym do procesu aplikacji. Ponieważ nie zrobiliśmy nic specjalnego w celu zbadania kodu, aplikacja zostanie uruchomiona do ukończenia 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
   

2. Aby zatrzymać debuger, wybierz pozycję Shift+F5 lub wybierz przycisk Zatrzymaj debugowanie na pasku narzędzi Debugowanie lub wybierz pozycję Debuguj>zatrzymaj debugowanie na pasku menu.

   

3. W oknie konsoli wybierz dowolny klucz, 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ą istotną funkcją niezawodnego debugowania. Możesz ustawić punkty przerwania, w których program Visual Studio ma wstrzymać uruchomiony kod, aby przyjrzeć się wartościom zmiennych lub zachowaniu pamięci albo sprawdzić, czy jest uruchamiana gałąź kodu.

2. Aby rozpocząć debugowanie, wybierz pozycję F5 lub wybierz przycisk Debuguj element docelowy na pasku narzędzi Standardowy lub wybierz przycisk Rozpocznij debugowanie na pasku narzędzi Debuguj lub wybierz pozycję Debuguj>rozpocznij debugowanie na pasku menu. Aplikacja zostanie uruchomiona, a debuger zostanie uruchomiony w wierszu kodu, w którym ustawiono punkt przerwania.

   

   Żółta strzałka wskazuje instrukcję, na której wstrzymano debuger. Wykonywanie aplikacji jest wstrzymane w tym samym momencie, a instrukcja nie została jeszcze wykonana.

   Gdy aplikacja nie jest uruchomiona, klawisz F5 uruchamia debuger, który uruchamia aplikację, dopóki nie osiągnie pierwszego punktu przerwania. Jeśli aplikacja zostanie wstrzymana w punkcie przerwania, klawisz F5 będzie kontynuować uruchamianie aplikacji do momentu osiągnięcia następnego punktu przerwania.

   Punkty przerwania to przydatna funkcja, gdy znasz wiersz lub sekcję kodu, którą chcesz szczegółowo zbadać. Aby uzyskać więcej informacji na temat różnych typów punktów przerwania, które można ustawić, takich jak punkty przerwania warunkowego, zobacz Używanie punktów przerwania.

Nawigowanie po kodzie i inspekcja danych przy użyciu porad dotyczących danych

1. Podczas gdy wykonywanie kodu jest wstrzymane na instrukcjiname += letters[i], umieść wskaźnik myszy na letters zmiennej, aby wyświetlić poradę dotyczącą danych pokazującą rozmiar tablicy i typ elementu. char[10]

   Uwaga

   Jedną z najbardziej przydatnych funkcji debugera jest możliwość inspekcji zmiennej. Często podczas próby debugowania problemu próbujesz dowiedzieć się, czy zmienne mają oczekiwane wartości w określonym czasie. Wyświetlanie wskazówek dotyczących danych to dobry sposób na sprawdzenie tego.

2. Rozwiń zmienną, letters aby wyświetlić wszystkie jej elementy tablicy i ich wartości.

   

3. Umieść kursor na zmiennej name , aby zobaczyć jego bieżącą wartość, która jest pustym ciągiem.

4. Aby przejść do następnej instrukcji debugera, wybierz pozycję F10 lub wybierz przycisk Przekrok na pasku narzędzi Debuguj lub wybierz pozycję Debuguj>krok powyżej na pasku menu. Wybierz klawisz F10 dwa razy więcej, aby przejść obok wywołania SendMessage metody.

   Klawisz F10 rozwija debuger bez przechodzenia do funkcji lub metod, chociaż ich kod nadal jest wykonywany. W ten sposób pominąliśmy debugowanie kodu w metodzie SendMessage , której nie interesujemy się teraz.

5. Aby iterować pętlę for kilka razy, wybierz klawisz F10 wielokrotnie. Podczas każdej iteracji pętli wstrzymaj się w punkcie przerwania, a następnie umieść kursor na zmiennej name , aby sprawdzić jej wartość w poradzie danych.

   

   Wartość zmiennej zmienia się wraz z każdą iterację for pętli, pokazując wartości f, a następnie fr, i fretak dalej. Aby przyspieszyć przechodzenie debugera przez pętlę, wybierz klawisz F5 , który przechodzi do punktu przerwania zamiast następnej instrukcji.

6. Gdy wykonywanie kodu jest wstrzymane w for pętli metody, wybierz klawisz F11 lub wybierz przycisk Przejdź do z paska narzędzi Debuguj lub wybierz pozycję Debuguj>krok do na pasku menu, dopóki nie osiągniesz SendMessage wywołania Main metody.

   Debuger powinien zostać wstrzymany w tym wierszu kodu:

   SendMessage(name, a[i]);

7. Aby przejść do SendMessage metody, ponownie wybierz klawisz F11 .

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

   

   Klawisz F11 pomaga dokładniej zbadać przepływ wykonywania kodu. Aby przejść do metody z wywołania metody, wybierz pozycję F11. Domyślnie debuger pomija przechodzenie do metod innych niżuser. Aby dowiedzieć się więcej o debugowaniu kodu nieużytkownika, zobacz Just My Code (Tylko mój kod).

   Po zakończeniu SendMessage debugowania metody możesz wrócić do for pętli main metody .

8. Aby opuścić metodęSendMessage, wybierz pozycję Shift+F11 lub wybierz przycisk Wyjdź na pasku narzędzi Debuguj lub wybierz pozycję Debuguj>wyjście na pasku menu.

   Krok wychodzący wznawia wykonywanie aplikacji i przechodzi do debugera, dopóki bieżąca metoda lub funkcja nie zwróci.

   Żółty wskaźnik jest widoczny z powrotem w for pętli Main metody, wstrzymany przy wywołaniu SendMessage metody. 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. Wybierz klawisz F5 , aby ponownie przejść do punktu przerwania.

2. W edytorze kodu umieść kursor na Console.WriteLine wywołaniu metody w metodzie SendMessage do momentu wyświetlenia przycisku Uruchom do kliknięcia . Etykietka narzędzia przycisku zawiera komunikat "Uruchom wykonanie tutaj".

   

3. Wybierz przycisk Uruchom, aby kliknąć. Alternatywnie po naciśnięciu kursora na instrukcji Console.WriteLinewybierz klawisze Ctrl+F10. Możesz też kliknąć prawym przyciskiem myszy wywołanie Console.WriteLine metody i wybrać polecenie Uruchom do kursora z menu kontekstowego.

   Debuger przechodzi do wywołania Console.WriteLine metody.

   Użycie przycisku Uruchom do kliknięcia jest podobne do ustawienia tymczasowego punktu przerwania i jest przydatne do szybkiego poruszania się w widocznym regionie kodu aplikacji w otwartym pliku.

Szybkie ponowne uruchamianie aplikacji

Aby ponownie uruchomić aplikację od początku w debugerze, wybierz klawisze Ctrl+Shift+F5 lub wybierz przycisk Uruchom ponownie na pasku narzędzi Debuguj lub wybierz pozycję Debuguj> ponownie na pasku menu.

Ponowne uruchomienie zatrzymuje debuger, a następnie uruchamia go ponownie w jednym kroku. Po ponownym uruchomieniu debugera jest uruchamiany do pierwszego punktu przerwania, czyli punktu przerwania ustawionego wcześniej wewnątrz for pętli, a następnie wstrzymywania.

Sprawdzanie zmiennych za pomocą okien Autos i Locals

Okna Autos i Locals zawierają wartości zmiennych podczas debugowania. Okna są dostępne tylko podczas sesji debugowania. W oknie Autos (Autos ) są wyświetlane zmienne używane w bieżącym wierszu, w których znajduje się debuger i poprzedni wiersz. W oknie Ustawienia lokalne są wyświetlane zmienne zdefiniowane w zakresie lokalnym, które są zwykle bieżącą funkcją lub metodą.

1. Podczas wstrzymania debugera wyświetl okno Autos w dolnej części edytora kodu.

   Jeśli okno Autos jest zamknięte, wybierz klawisze Ctrl+D, A lub wybierz pozycję Debuguj>autos windows>na pasku menu.

2. Gdy debuger nadal jest wstrzymany, wyświetl okno Ustawienia lokalne na karcie obok okna Autos .

   Jeśli okno Ustawienia lokalne jest zamknięte, wybierz klawisze Ctrl+D, L lub wybierz pozycję Debuguj>ustawienia lokalne systemu Windows.>

3. W oknie Ustawienia lokalne rozwiń zmiennąletters, aby wyświetlić jej elementy tablicy i ich wartości.

   

Aby uzyskać więcej informacji o oknach Autos i Locals , zobacz Inspekcja zmiennych w oknach Autos and Locals (Sprawdzanie zmiennych w oknach Autos and Locals).

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ń

Stos wywołań może ułatwić zrozumienie przepływu wykonywania aplikacji, pokazując kolejność wywoływania metod i funkcji.

1. Podczas gdy debuger jest wstrzymany w for pętli, wyświetl okno stosu wywołań, które zostanie domyślnie otwarte w prawym dolnym okienku edytora kodu.

   Jeśli okno stosu wywołań jest zamknięte, wybierz klawisze Ctrl+D, C lub wybierz pozycję Debuguj>stos wywołań systemu Windows>na pasku menu.

   W oknie Stos wywołań zobaczysz żółty wskaźnik w bieżącej Main metodzie.

2. Wybierz klawisz F11 kilka razy, aż zobaczysz wstrzymanie debugera w metodzie SendMessage .

   Górny wiersz okna stosu wywołań przedstawia bieżącą SendMessage funkcję, która jest metodą . Drugi wiersz pokazuje, że SendMessage metoda została wywołana z Main metody .

   

   Uwaga

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

   W oknie Stos wywołań możesz kliknąć dwukrotnie wiersz kodu, aby przejść do tego kodu źródłowego, który zmienia bieżący zakres 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 lub przejść do kodu źródłowego.

Aby uzyskać więcej informacji na temat stosu wywołań, zobacz How to: Examine the Call Stack (Instrukcje: badanie stosu wywołań).

Zmienianie przepływu wykonywania

Wskaźnik wykonywania można przenieść, aby zmienić przepływ aplikacji podczas debugowania.

1. Gdy debuger wstrzymał się przy SendMessage wywołaniu metody w for pętli, wybierz klawisz F11 trzy razy, aby przejść do SendMessage metody i przejść obok Console.WriteLine metody po jej wykonaniu.

   Debuger jest teraz wstrzymany na ostatnim zamykającym nawiasie klamrowym SendMessage metody .

2. Użyj myszy, aby chwycić żółtą strzałkę lub wskaźnik wykonywania (na lewym marginesie), a następnie przeciągnij wskaźnik w górę o jedną linię.

   Debuger jest teraz z powrotem w instrukcji Console.WriteLine .

3. Wybierz pozycję F11.

   Debuger ponownie uruchamia metodę Console.WriteLine i zobaczysz zduplikowany wiersz w danych wyjściowych okna konsoli.

4. Wybierz pozycję F5 , aby kontynuować uruchamianie aplikacji.

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

Użyj tej funkcji z ostrożnością. W etykietce narzędzia wskaźnika wykonywania zostanie wyświetlone ostrzeżenie o możliwości niezamierzonych konsekwencji. Mogą też zostać wyświetlone inne ostrzeżenia. Przeniesienie wskaźnika wykonywania nie może przywrócić aplikacji do wcześniejszego stanu.

Aby uzyskać więcej informacji na temat zmiany przepływu wykonywania, zobacz Przenoszenie wskaźnika w celu zmiany przepływu wykonywania.

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