Sprawdzanie zmiennych i zwracanych wartości w debugerze programu Visual Studio

Podczas próby debugowania problemu często próbujesz dowiedzieć się, czy zmienne przechowują wartości, które mają być w określonym stanie aplikacji. Niektóre z najbardziej przydatnych funkcji debugera to te, które umożliwiają inspekcję zmiennych.

W tym artykule pokazano, jak sprawdzić zmienne i wyświetlić wartości zwracane przy użyciu debugera w programie Visual Studio. Debuger udostępnia kilka wygodnych sposobów wykonywania tych zadań, w tym:

• W edytorze kodu można wyświetlać porady dotyczące danych i wbudowane wartości zwracane
• W oknach debugera (Autos, Locals i Watch windows) można wyświetlić wartości zmiennych
• W wizualizatorach można wyświetlać duże ciągi lub złożone obiekty platformy .NET

Te funkcje są dostępne tylko podczas debugowania. Aby dowiedzieć się, jak uruchomić sesję debugowania, zobacz Rozpocznij debugowanie i wprowadź tryb przerwania.

Notatka

Jeśli po raz pierwszy próbowano debugować kod, warto przeczytać Debugowanie dla początkujących i Techniki debugowania i narzędzia przed przejściem do tego artykułu.

Wyświetlanie zmiennych w edytorze kodu

Często podczas debugowania chcesz szybko sprawdzić wartości właściwości w obiektach w edytorze kodu, a porady dotyczące danych są dobrym sposobem na to.

Podczas wstrzymania w debugerze umieść kursor myszy nad obiektem, aby zobaczyć jego wartość lub wartość jego domyślnej właściwości.

Jeśli zmienna ma właściwości, możesz rozwinąć obiekt, aby wyświetlić wszystkie jego właściwości.

Aby uzyskać szczegółowe informacje na temat korzystania z porad dotyczących danych, zobacz Wyświetlanie wartości danych w poradach dotyczących danych.

Wyświetlanie wbudowanych wartości wywołań metod w edytorze kodu

W kodzie .NET i C++ można sprawdzić wartości zwracane podczas przechodzenia do wywołania metody lub poza niego, co może być przydatne, gdy wartość zwracana nie jest przechowywana w zmiennej lokalnej. Metodę można użyć jako parametru lub jako zwracanej wartości innej metody.

Począwszy od programu Visual Studio 2022 w wersji 17.12, można wyświetlić zwracane wartości wywołań metod bezpośrednio, a nie tylko w oknie Autos.

Po włączeniu funkcji Copilot możesz również uzyskać ukierunkowaną pomoc dotyczącą bezpośredniej wartości zwracanej, korzystając z przycisku Zapytaj Copilot, który pojawia się w podpowiedzi dla wartości zwracanej.

Obserwuj zmienne

Możesz użyć okna Watch, aby określić zmienną (lub wyrażenie), którą chcesz mieć na oku.

Podczas debugowania kliknij prawym przyciskiem myszy obiekt w edytorze kodu i wybierz polecenie Dodaj zegarek. Zostanie otwarte okno obserwacji.

Okno

W tym przykładzie masz ustawiony zegarek na obiekcie i możesz zobaczyć jego zmianę wartości podczas przechodzenia przez debuger. W przeciwieństwie do innych okien zmiennych, okna Watch zawsze wyświetlają obserwowane zmienne (są wyszarzane, gdy znajdują się poza zakresem).

Aby uzyskać szczegółowe informacje, zobacz Ustawianie zegarka za pomocą okien Obserwacja i Szybka Obserwacja.

Uzyskiwanie pomocy dotyczącej sztucznej inteligencji

Jeśli masz copilot, możesz uzyskać pomoc dotyczącą sztucznej inteligencji podczas przeglądania zmiennych w edytorze kodu lub w oknach Autos lub Locals. Podczas debugowania kliknij prawym przyciskiem myszy zmienną i użyj przycisku Ask Copilot. W tym scenariuszu Copilot zna już kontekst pytania, więc nie musisz podawać kontekstu na czacie. Aby uzyskać więcej informacji, zobacz Debug with Copilot.

Sprawdzanie zmiennych w oknach debugera (automatyczne i lokalne)

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 wokół bieżącej instrukcji, w której debuger jest wstrzymany. W oknie Locals są wyświetlane zmienne zdefiniowane w zakresie lokalnym, które są zwykle bieżącą funkcją lub metodą.

• Aby otworzyć okno Autos, podczas debugowania wybierz pozycję Debugowanie>Windows>Autoslub naciśnij Ctrl+Alt+V>A.

  Okno Autos jest dostępne dla języków C#, Visual Basic, C++i Python, ale nie dla języków JavaScript lub F#.

• Aby otworzyć okno Locals, podczas debugowania wybierz Debug>Windows>Localslub naciśnij Alt+4.

Rozwijane tablice i obiekty są wyświetlane w oknach Autos i Locals . Wybierz strzałkę z lewej strony nazwy zmiennej, aby rozwinąć widok, aby wyświetlić pola i właściwości. Oto przykład obiektu System.IO.FileStream w oknie Locals:

Czerwona wartość w oknie Locals lub Autos oznacza, że wartość zmieniła się od ostatniej oceny. Zmiana może pochodzić z poprzedniej sesji debugowania lub zmiany wartości w oknie.

Domyślny format liczbowy w oknach debugera to liczba dziesiętna. Aby zmienić go na szesnastkowy, kliknij prawym przyciskiem myszy okno Locals lub Autos i wybierz pozycję Szesnastkowe wyświetlanie. Ta zmiana ma wpływ na wszystkie okna debugera.

Edytowanie wartości zmiennych w oknie Autos lub Locals

Aby edytować wartości większości zmiennych w oknach Autos lub Ustawienia lokalne, kliknij dwukrotnie wartość i wprowadź nową wartość.

Możesz wprowadzić wyrażenie dla wartości, na przykład a + b. Debuger akceptuje najbardziej prawidłowe wyrażenia języka.

W natywnym kodzie C++ może być konieczne zakwalifikowanie kontekstu nazwy zmiennej. Aby uzyskać więcej informacji, zobacz operator kontekstu (C++).

Ostrożność

Przed zmianą wartości i wyrażeń upewnij się, że rozumiesz konsekwencje. Niektóre możliwe problemy to:

• Ocena niektórych wyrażeń może zmienić wartość zmiennej lub w inny sposób wpłynąć na stan programu. Na przykład ocena var1 = ++var2 zmienia wartość zarówno var1, jak i var2. Mówi się, że wyrażenia te mają skutki uboczne. Skutki uboczne mogą powodować nieoczekiwane wyniki, jeśli ich nie znasz.

• Edytowanie wartości zmiennoprzecinkowych może spowodować niewielkie niedokładności z powodu konwersji składników ułamkowych z formatu dziesiętnego na binarny. Nawet pozornie nieszkodliwa edycja może spowodować zmiany w niektórych bitach zmiennej zmiennoprzecinkowej.

Wyszukiwanie w oknie Autos lub Locals

Słowa kluczowe można wyszukiwać w kolumnach Nazwa, Wartość i Typ okna Autos lub okna Lokalnych, korzystając z paska wyszukiwania nad każdym oknem. Naciśnij ENTER lub wybierz jedną ze strzałek, aby wykonać wyszukiwanie. Aby anulować trwające wyszukiwanie, wybierz ikonę "x" na pasku wyszukiwania.

Użyj strzałek w lewo i w prawo (odpowiednio Shift+F3 i F3), aby nawigować między znalezionymi dopasowaniami.

Aby dostosować dokładność wyszukiwania, użyj listy rozwijanej Wyszukaj głębiej w górnej części okna Autos lub Lokale, aby wybrać, ile poziomów głębokości chcesz przeszukać w zagnieżdżonych obiektach.

Przypinanie właściwości w oknach Autos lub Locals

Notatka

Ta funkcja jest obsługiwana dla platformy .NET Core 3.0 lub nowszej.

Można szybko sprawdzić obiekty według ich właściwości w oknach Autos and Locals za pomocą narzędzia Przypięte właściwości. Aby użyć tego narzędzia, umieść kursor nad właściwością i wybierz ikonę pinezki, która się pojawi, lub kliknij prawym przyciskiem myszy, a następnie wybierz opcję Zaznacz jako ulubiony w wyświetlonym menu kontekstowym. To przenosi tę właściwość na początek listy właściwości obiektu, a nazwa i wartość właściwości są wyświetlane w kolumnie Wartość. Aby odpiąć właściwość, wybierz ponownie ikonę pinezki lub wybierz opcję Odepnij członka z ulubionych w menu kontekstowym.

Można również przełączać nazwy właściwości i filtrować nieprzypinane właściwości podczas wyświetlania listy właściwości obiektu w oknach Autos lub Locals. Dostęp do każdej opcji można uzyskać, wybierając przyciski na pasku narzędzi powyżej okien Autos lub Locals.

Zmienianie kontekstu okna Autos lub Locals

Możesz użyć paska narzędzi Lokalizacja debugowania, aby wybrać żądaną funkcję, wątek lub proces, co zmienia kontekst okien Autos i Locals.

Aby włączyć pasek narzędzi Debug Location, kliknij pustą część obszaru paska narzędzi i wybierz pozycję Debug Location z listy rozwijanej lub wybierz pozycję Widok>Paski narzędzi>Debug Location.

Ustaw punkt przerwania i rozpocznij debugowanie. Gdy punkt przerwania zostanie osiągnięty, działanie zostanie wstrzymane, a lokalizację można zobaczyć na pasku narzędzi Lokalizacja debugowania.

Zrzut ekranu przedstawiający pasek narzędzi Lokalizacja Debugowania.Debug Location toolbar Pasek narzędzi Lokalizacja Debugowania

Różnice języka w oknie Autos (C#, C++, Visual Basic, Python)

Różne języki kodu wyświetlają różne zmienne w oknie Autos.

• W języku C# i Visual Basic okno Autos wyświetla dowolną zmienną używaną w bieżącym lub poprzednim wierszu. Na przykład w kodzie C# lub Visual Basic zadeklaruj następujące cztery zmienne:

       public static void Main()
       {
          int a, b, c, d;
          a = 1;
          b = 2;
          c = 3;
          d = 4;
       }
  

  Ustaw punkt przerwania w wierszu c = 3;i uruchom debuger. Po wstrzymaniu wykonywania zostanie wyświetlone okno Autos:

  

  Wartość c wynosi 0, ponieważ wiersz c = 3 nie został jeszcze wykonany.

• W języku C++okno Autos wyświetla zmienne używane w co najmniej trzech wierszach przed bieżącym wierszem, w którym wykonywanie jest wstrzymane. Na przykład w kodzie C++ zadeklaruj sześć zmiennych:

       void main() {
           int a, b, c, d, e, f;
           a = 1;
           b = 2;
           c = 3;
           d = 4;
           e = 5;
           f = 6;
       }
  

  Ustaw punkt przerwania w wierszu e = 5; i uruchom debuger. Po zatrzymaniu wykonywania zostanie wyświetlone okno Autos:

  

  Zmienna e jest niezainicjowana, ponieważ wiersz e = 5 nie został jeszcze wykonany.

Wyświetlanie wartości zwracanych w oknie Autos

W poniższym przykładzie ten kod języka C# dodaje zwracane wartości dwóch funkcji:

static void Main(string[] args)
{
    int a, b, c, d;
    a = 1;
    b = 2;
    c = 3;
    d = 4;
    int x = sumVars(a, b) + subtractVars(c, d);
}

private static int sumVars(int i, int j)
{
    return i + j;
}

private static int subtractVars(int i, int j)
{
    return j - i;
}

Aby wyświetlić zwracane wartości wywołań metody sumVars() i subtractVars() w oknie Autos:

1. Ustaw punkt przerwania w wierszu int x = sumVars(a, b) + subtractVars(c, d);.

2. Rozpocznij debugowanie, a gdy wykonywanie zostanie wstrzymane w punkcie przerwania, wybierz pozycję Krok przez lub naciśnij F10. W oknie Autos powinny zostać wyświetlone następujące wartości zwracane:

   

Otwieranie wizualizatora w celu sprawdzenia zmiennych

Podczas debugowania w programie Visual Studio można wyświetlać duże ciągi lub złożone obiekty za pomocą wbudowanych wizualizatorów, które ułatwiają inspekcję danych. Na przykład:

• Wizualizator ciągów pokazuje ciągi tekstowe, XML, HTML i JSON, które są zbyt długie do tooltipu danych lub okna debugera. Może również pomóc zidentyfikować źle sformułowane ciągi. Aby uzyskać więcej informacji, zobacz Wyświetlanie ciągów w wizualizatorze ciągów.
• Wizualizatory DataSet i IEnumerable pokazują obiekty kolekcji .NET w wizualizatorze tabelarycznym. Aby uzyskać więcej informacji, zobacz wizualizatory tabelaryczne w Visual Studio (obiekty).

Wizualizatory są wyświetlane w oknach Autos , poradach dotyczących danych i innych oknach debugera.

Notatka

Jeśli musisz sprawdzić elementy interfejsu użytkownika XAML lub WPF w wizualizatorze, zapoznaj się z artykułem Sprawdzanie właściwości XAML podczas debugowania lub Jak używać wizualizatora drzewa WPF.

Aby otworzyć wizualizator, należy wstrzymać go podczas debugowania. Umieść kursor na zmiennej, która ma obsługiwaną wartość wizualizatora, a następnie wybierz ikonę lupy .

Powiązana zawartość

• Co to jest debugowanie?
• techniki debugowania i narzędzia
• Najpierw przyjrzyj się debugowaniu
• Okna debuggera