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 Najpierw zobacz 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 jest pierwszym razem, kiedy próbujesz debugować kod, możesz chcieć przeczytać Debugowanie dla absolutnie początkujących przed przystąpieniem 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#.

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

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 obciążenie .NET desktop development.

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

Jeśli masz już Visual Studio, ale pakiet programistyczny dla komputerów .NET nie jest zainstalowany, przejdź do Narzędzia>, a następnie wybierz Pobierz narzędzia i funkcje..., które uruchomią Instalator Visual Studio. W Instalatorze 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 cokolwiek dodasz.

Otwórz program Visual Studio. Jeśli okno uruchamiania nie jest otwarte, wybierz Plik>Okno uruchamiania.
W oknie uruchamiania wybierz pozycję Utwórz nowy projekt.

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 / 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.
W oknie Konfigurowanie nowego projektu wprowadź getStartedDebugging w polu Nazwa projektu . Następnie wybierz Dalej.
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 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.

Aby uruchomić debuger, wybierz 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.

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
```
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.
W oknie konsoli wybierz dowolny klucz, aby zamknąć okno konsoli.

Ustawianie punktu przerwania i uruchamianie debugera

for W pętli Main funkcji ustaw punkt przerwania, klikając w lewym marginesie w wierszu kodu poniżej:

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.
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 uruchamia się, a debuger uruchamia się na linii kodu, w której 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, F5 uruchamia debuger, który uruchamia aplikację, dopóki nie osiągnie pierwszego punktu przerwania. Jeśli aplikacja zostanie wstrzymana w punkcie przerwania, 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 podpowiedzi danych

Podczas gdy wykonywanie kodu jest zatrzymane na instrukcji name += letters[i], najechać kursorem myszy na zmienną letters, aby wyświetlić wskazówkę danych pokazującą rozmiar tablicy i typ elementu. char[10]

Uwaga / Notatka

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 to, aby to zweryfikować.
Rozwiń zmienną, letters aby wyświetlić wszystkie jej elementy tablicy i ich wartości.
Umieść kursor na zmiennej name , aby zobaczyć jego bieżącą wartość, która jest pustym ciągiem.
Aby przejść do następnej instrukcji, naciśnij F10, wybierz przycisk Przejdź nad na pasku narzędzi Debug lub wybierz Debug>Przejdź nad z menu. Wybierz F10 dwa razy więcej, aby przejść obok wywołania SendMessage metody.

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.
Aby iterować pętlę for kilka razy, wybierz F10 wielokrotnie. Podczas każdej iteracji pętli zatrzymaj się na punkcie przerwania, a następnie umieść kursor na zmiennej name, aby sprawdzić jej wartość w podpowiedzi danych.

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. Aby przyspieszyć przechodzenie debugera przez pętlę, wybierz F5, co pozwala przejść bezpośrednio do punktu przerwania, zamiast do następnej instrukcji.
Gdy wykonywanie kodu jest wstrzymane w for pętli Main metody, wybierz 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 metody.

Debuger powinien zostać wstrzymany w tym wierszu kodu:

SendMessage(name, a[i]);
Aby przejść do SendMessage metody, ponownie wybierz F11 .

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

F11 pomaga dokładniej zbadać przepływ wykonywania kodu. Aby przejść do metody z wywołania metody, wybierz F11. Domyślnie debuger pomija wchodzenie w metody niebędące metodami użytkownika. Aby dowiedzieć się więcej o debugowaniu kodu nieużytkownika, zobacz Just My Code (Tylko mój kod).

Po zakończeniu debugowania metody SendMessage możesz wrócić do pętli for w metodzie main.
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 wyjścia wznawia wykonywanie aplikacji i kontynuuje działanie debugera, dopóki bieżąca metoda lub funkcja nie zostanie zakończona i nie zwróci wyniku.

Widzisz żółty wskaźnik z powrotem w pętli for metody Main, zatrzymany przy wywołaniu metody 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

Wybierz F5 , aby ponownie przejść do punktu przerwania.
W edytorze kodu najedź kursorem na wywołanie metody Console.WriteLine w metodzie SendMessage do momentu wyświetlenia przycisku Uruchom do Kliknięcia. Etykietka narzędzia przycisku zawiera komunikat "Uruchom wykonanie tutaj".
Wybierz przycisk Uruchom, aby kliknąć . Alternatywnie po naciśnięciu kursora na instrukcji Console.WriteLine wybierz 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 Ctrl+Shift+F5 lub wybierz przycisk Uruchom ponownie na pasku narzędzi Debuguj lub wybierz pozycję Debuguj>ponownie na pasku menu.

Zrzut ekranu przedstawiający przycisk Uruchom ponownie na pasku narzędzi debugowania w Visual Studio 2022.

Ponowne uruchomienie zatrzymuje debuger, a następnie uruchamia go ponownie w jednym kroku. Po ponownym uruchomieniu debugera zatrzymuje się na pierwszym punkcie przerwania, czyli tym, który ustawiono wcześniej wewnątrz pętli for, a następnie wstrzymuje działanie.

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 są wyświetlane zmienne używane w bieżącym wierszu, w którym znajduje się debuger, oraz w poprzednim wierszu. W oknie Locals są wyświetlane zmienne zdefiniowane w zakresie lokalnym, które są zwykle bieżącą funkcją lub metodą.

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

Jeśli okno Autos jest zamknięte, wybierz Ctrl+D, A lub wybierz pozycję Debug>Windows>Autos z paska menu.
Gdy debuger nadal jest wstrzymany, wyświetl okno Ustawienia lokalne na karcie obok okna Autos .

Jeśli okno Ustawienia lokalne jest zamknięte, wybierz Ctrl+D, L lub wybierz pozycję Debuguj>ustawienia lokalne systemu>.
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 .

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

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

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 Ctrl+D, C lub z menu wybierz pozycję Debuguj>Windows>Stos Wywołań na pasku menu.

W oknie Stos wywołań zobaczysz żółty wskaźnik przy bieżącej Main metodzie.
Wybierz F11 kilka razy, aż zobaczysz wstrzymanie debugera w metodzie SendMessage .

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

Uwaga / Notatka

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 na wiersz kodu, aby przejść do tego kodu źródłowego, co zmienia bieżący zakres inspekcji debugera. 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 ustawić punkty przerwania w określonych funkcjach, kontynuować działanie debuggera 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ń).

Dalsze kroki

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

Najpierw przyjrzyj się debuggerowi

Sprzężenie zwrotne

Czy ta strona była pomocna?

Last updated on 2025-12-12