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. 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ć obserwacje dla zmiennych, aby zobaczyć, kiedy wartości się zmieniają. Możesz sprawdzić ścieżkę wykonywania kodu, aby sprawdzić, czy działa gałąź kodu.

Jeśli ten artykuł to pierwszy raz, gdy spróbujesz debugować kod, zobacz Debugowanie dla całkowicie początkujących. Jeśli chcesz wyświetlić funkcje debugera wyższego poziomu, zobacz Omówienie debugera programu Visual Studio.

Mimo że aplikacja demonstracyjna to C#, większość funkcji ma zastosowanie do języków C++, Visual Basic, 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 języku C#.

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 i pakiet rozwój aplikacji komputerowych dla platformy .NET.

Jeśli musisz zainstalować program Visual Studio, pobierz go bezpłatnie w programie Visual Studio do pobrania.

Jeśli masz już Visual Studio, ale nie zainstalowano narzędzia rozwoju aplikacji desktopowych .NET, przejdź do Narzędzia>Pobierz narzędzia i funkcje.... W Instalatorze programu Visual Studio wybierz narzędzie rozwoju aplikacji desktopowych .NET, a następnie wybierz Modyfikuj.

Tworzenie projektu

Najpierw utwórz projekt aplikacji konsolowej C#/.NET. Szablon projektu zawiera wszystkie potrzebne pliki przed dodaniem czegokolwiek.

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

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 10.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 w tym artykule są używane skróty klawiaturowe. Jest to szybki sposób wykonywania poleceń debugera. Dostępne są również równoważne polecenia, takie jak polecenia paska narzędzi lub menu.

1. 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. Od kiedy rozpoczęto debugowanie, aplikacja uruchamia się do końca i widać 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 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. Możesz przyjrzeć się wartościom zmiennych lub zachowaniu pamięci lub sprawdzić, czy działa 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 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. Wykonanie aplikacji wstrzymuje się 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 jest wstrzymana w punkcie przerwania, klawisz F5 kontynuuje 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 odpowiedniego typu punktu przerwania.

Nawigowanie po kodzie i inspekcja danych przy użyciu podpowiedzi danych

1. 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ć.

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, 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 pominięto debugowanie kodu w metodzie SendMessage , co nie jest teraz istotne.

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

6. 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]);

7. 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 metody main.

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

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

2. 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".

   

3. 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 ustawiania tymczasowego punktu przerwania. To podejście 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.

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

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

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 Ctrl+D, L lub wybierz pozycję Debuguj>ustawienia lokalne systemu>.

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

   

Aby uzyskać więcej informacji na temat okien Autos i Locals , zobacz Sprawdzanie zmiennych i zwracanych wartości.

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. Po ustawieniu punktu kontrolnego na zmiennej name, przejdź przez kod, aby zobaczyć zmianę wartości zmiennej name 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 pomóc w zrozumieniu przepływu wykonywania aplikacji. Pokazuje kolejność wywoływanych 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 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.

2. 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 Wyświetlanie stosu wywołań.

Następny krok

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