Oglądaj zmienne za pomocą okien zegarków i QuickWatch

Podczas debugowania możesz oglądać zmienne i wyrażenia za pomocą okien zegarka Watch i QuickWatch . Okna są dostępne tylko podczas sesji debugowania.

Okna kontrolne mogą wyświetlać kilka zmiennych naraz podczas debugowania. W oknie dialogowym QuickWatch jest wyświetlana pojedyncza zmienna i musi zostać zamknięta przed kontynuowaniem debugowania. Aby uzyskać więcej informacji na temat korzystania z funkcji QuickWatch, zobacz Obserwowanie pojedynczej zmiennej lub wyrażenia za pomocą aplikacji QuickWatch.

Uwaga

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

Obserwowanie zmiennych za pomocą okna obserwowania

Możesz otworzyć więcej niż jedno okno czujki i obserwować więcej niż jedną zmienną w oknie czujki .

Aby na przykład ustawić zegarek na wartości a, bi c w następującym kodzie:

int main()
{
    int a, b, c;
    a = 1;
    b = 2;
    c = 0;

    for (int i = 0; i < 10; i++)
    {
        a++;
        b *= 2;
        c = a + b;
    }

    return 0;
}

1. Ustaw punkt przerwania w c = a + b; wierszu, klikając lewy margines, wybierając pozycję Debuguj>przełącz punkt przerwania lub naciskając klawisz F9.

2. Rozpocznij debugowanie, wybierając zieloną strzałkę Start lub Rozpocznij>debugowanie lub naciśnij klawisz F5. Wykonywanie wstrzymuje się w punkcie przerwania.

3. Otwórz okno Obserwowanie, wybierając pozycję Debuguj >zegarek Windows>Watch>1 lub naciskając klawisze Ctrl+Alt+W>1.

   Możesz otworzyć dodatkowe okna Zegarek , wybierając pozycję Windows 2, 3 lub 4.

4. W oknie Obserwowanie wybierz pusty wiersz i wpisz zmienną a. Wykonaj to samo dla b i c.

   

5. Kontynuuj debugowanie, wybierając pozycję Debuguj>krok do lub naciskając klawisz F11 zgodnie z potrzebami, aby przejść dalej. Wartości zmiennych w oknie Obserwowanie zmieniają się podczas iterowania przez pętlę for .

Uwaga

Tylko w przypadku języka C++,

• Może być konieczne zakwalifikowanie kontekstu nazwy zmiennej lub wyrażenia, które używa nazwy zmiennej. Kontekst jest funkcją, plikiem źródłowym lub modułem, w którym znajduje się zmienna. Jeśli musisz zakwalifikować kontekst, użyj składni operatora kontekstu (C++) w polu Nazwa w oknie Obserwowanie.

• Nazwy rejestru i nazwy zmiennych można dodać przy użyciu nazwy $<register lub @<register> name> do nazwy w oknie Obserwowanie. Aby uzyskać więcej informacji, zobacz Pseudovariables (Pseudovariables).

Używanie wyrażeń w oknie czujki

Możesz obserwować dowolne prawidłowe wyrażenie rozpoznane przez debuger w oknie czujki.

Na przykład w przypadku kodu w poprzedniej sekcji możesz uzyskać średnią z trzech wartości, wprowadzając wartość (a + b + c) / 3 w oknie Czujka :

Reguły obliczania wyrażeń w oknie Watch są zazwyczaj takie same jak reguły obliczania wyrażeń w języku kodu. Jeśli wyrażenie zawiera błąd składni, należy oczekiwać tego samego błędu kompilatora co w edytorze kodu. Na przykład literówka w poprzednim wyrażeniu generuje ten błąd w oknie Obserwowanie :

Okrąg z dwiema falistymi liniami ikona może pojawić się w oknie Czujka . Ta ikona oznacza, że debuger nie ocenia wyrażenia z powodu potencjalnej zależności między wątkami. Ocena kodu wymaga tymczasowego uruchomienia innych wątków w aplikacji, ale ponieważ działasz w trybie przerwania, wszystkie wątki w aplikacji są zwykle zatrzymywane. Zezwolenie innym wątkom na tymczasowe uruchamianie może mieć nieoczekiwany wpływ na stan aplikacji, a debuger może ignorować zdarzenia, takie jak punkty przerwania i wyjątki w tych wątkach.

Wyszukiwanie w oknie Obserwowanie

Słowa kluczowe można wyszukiwać w kolumnach Nazwa, Wartość i Typ okna Obserwowanie przy użyciu paska wyszukiwania nad każdym oknem. Naciśnij klawisz 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 przechodzić między znalezionymi dopasowaniami.

Aby wyszukiwać mniej więcej dokładnie, użyj listy rozwijanej Wyszukaj głębiej w górnej części okna Obserwowanie , aby wybrać, ile poziomów głębokości chcesz wyszukać w zagnieżdżonych obiektach.

Przypinanie właściwości w oknie Czujka

Uwaga

Ta funkcja jest obsługiwana w programie .NET Core 3.0 lub nowszym.

Możesz szybko sprawdzić obiekty według ich właściwości w oknie Obserwowanie 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 zostanie wyświetlona lub kliknij prawym przyciskiem myszy, a następnie wybierz opcję Przypnij element członkowski jako ulubiony w wyświetlonym menu kontekstowym. To bąbelki w górę tej właściwości na początku listy właściwości obiektu, a nazwa właściwości i wartość są wyświetlane w kolumnie Wartość . Aby odpiąć właściwość, wybierz ponownie ikonę pinezki lub wybierz opcję Odepnij element członkowski jako ulubiony w menu kontekstowym.

Można również przełączać nazwy właściwości i filtrować właściwości nieprzypinane podczas wyświetlania listy właściwości obiektu w oknie Obserwowanie. Dostęp do obu opcji można uzyskać, wybierając przyciski na pasku narzędzi nad oknem zegarka.

Odświeżanie wartości zegarka

Ikona odświeżania (strzałka cykliczna) może pojawić się w oknie Obserwowanie po obliczeniu wyrażenia. Ikona odświeżania wskazuje błąd lub wartość, która jest nieaktualna.

Aby odświeżyć wartość, wybierz ikonę odświeżania lub naciśnij spację. Debuger próbuje ponownie sprawdzić wyrażenie. Jednak możesz nie chcieć lub mieć możliwość ponownego oszacowania wyrażenia, w zależności od tego, dlaczego wartość nie została obliczona.

Zatrzymaj wskaźnik myszy na ikonie odświeżania lub wyświetl kolumnę Value z powodu, że wyrażenie nie zostało ocenione. Przyczyny:

• Wystąpił błąd podczas oceniania wyrażenia, jak w poprzednim przykładzie. Może wystąpić przekroczenie limitu czasu lub zmienna może być poza zakresem.

• Wyrażenie ma wywołanie funkcji, które może wywołać efekt uboczny w aplikacji. Zobacz Efekty uboczne wyrażenia.

• Automatyczna ocena właściwości i niejawnych wywołań funkcji jest wyłączona.

Jeśli zostanie wyświetlona ikona odświeżania, ponieważ automatyczna ocena właściwości i niejawnych wywołań funkcji jest wyłączona, możesz ją włączyć, wybierając pozycję Włącz ocenę właściwości i inne niejawne wywołania funkcji w obszarze Narzędzia>Opcje>Debugowanie>ogólne.

Aby zademonstrować użycie ikony odświeżania:

1. W obszarze Narzędzia>Opcje>debugowania>Ogólne wyczyść pole wyboru Włącz ocenę właściwości i inne niejawne wywołania funkcji.

2. Wprowadź następujący kod, a w oknie Czujka ustaw zegarek we list.Count właściwości .

   static void Main(string[] args)
   {
       List<string> list = new List<string>();
       list.Add("hello");
       list.Add("goodbye");
   }
   

3. Uruchom debugowanie. W oknie Obserwowanie jest wyświetlany komunikat podobny do następującego:

   

4. Aby odświeżyć wartość, wybierz ikonę odświeżania lub naciśnij spację. Debuger ponownie waliduje wyrażenie.

Efekty uboczne wyrażeń

Ocena niektórych wyrażeń może zmienić wartość zmiennej lub w inny sposób wpływać na stan aplikacji. Na przykład obliczeniu następującego wyrażenia zmienia wartość elementu var1:

var1 = var2

Ten kod może spowodować efekt uboczny. Skutki uboczne mogą utrudnić debugowanie, zmieniając sposób działania aplikacji.

Wyrażenie z efektami ubocznymi jest oceniane tylko raz, po pierwszym wprowadzeniu. Następnie wyrażenie jest wyszarane w oknie Obserwowanie , a dalsze oceny są wyłączone. W kolumnie Etykietka narzędzia lub Wartość wyjaśniono, że wyrażenie powoduje efekt uboczny. Możesz wymusić ponowną wycenę, wybierając ikonę odświeżania wyświetlaną obok wartości.

Jednym ze sposobów zapobiegania oznaczeniu skutków ubocznych jest wyłączenie automatycznej oceny funkcji. W obszarze Narzędzia>Opcje>Debugowanie>ogólne usuń zaznaczenie pozycji Włącz ocenę właściwości i inne niejawne wywołania funkcji.

W przypadku języka C# tylko wtedy, gdy ocena właściwości lub niejawnych wywołań funkcji jest wyłączona, można wymusić ocenę, dodając modyfikator formatu ac do zmiennej Nazwa w oknie Obserwowanie . Zobacz Specyfikatory formatu w języku C#.

Używanie identyfikatorów obiektów w oknie Obserwowanie (C# i Visual Basic)

Czasami chcesz obserwować zachowanie określonego obiektu. Na przykład możesz chcieć śledzić obiekt, do którego odwołuje się zmienna lokalna, po tym jak ta zmienna wyszła poza zakres. W językach C# i Visual Basic można tworzyć identyfikatory obiektów dla określonych wystąpień typów odwołań i używać ich w oknie Obserwowanie i w warunkach punktu przerwania. Identyfikator obiektu jest generowany przez usługi debugowania środowiska uruchomieniowego języka wspólnego (CLR) i skojarzone z obiektem.

Uwaga

Identyfikatory obiektów tworzą słabe odwołania, które nie uniemożliwiają odśmiecaniu pamięci obiektu. Są one prawidłowe tylko dla bieżącej sesji debugowania.

W poniższym kodzie MakePerson() metoda tworzy zmienną Person lokalną:

class Person
{
    public Person(string name)
    {
        Name = name;
    }
    public string Name { get; set; }
}

public class Program
{
    static List<Person> _people = new List<Person>();
    public static void Main(string[] args)
    {
        MakePerson();
        DoSomething();
    }

    private static void MakePerson()
    {
        var p = new Person("Bob");
        _people.Add(p);
    }

    private static void DoSomething()
    {
        // more processing
         Console.WriteLine("done");
    }
}

Aby dowiedzieć się, jak nazwa Person metody znajduje się w metodzie DoSomething() , możesz dodać odwołanie do identyfikatora Person obiektu w oknie Obserwowanie .

1. Ustaw punkt przerwania w kodzie po utworzeniu Person obiektu.

2. Uruchom debugowanie.

3. Po wstrzymaniu wykonywania w punkcie przerwania otwórz okno Ustawienia lokalne, wybierając pozycję Debuguj>ustawienia lokalne systemu Windows.>

4. W oknie Ustawienia lokalne kliknij prawym przyciskiem myszy zmienną Person i wybierz pozycję Ustaw identyfikator obiektu.

   Powinien zostać wyświetlony znak dolara ($) oraz numer w oknie Ustawienia lokalne , czyli identyfikator obiektu.

5. Dodaj identyfikator obiektu do okna Obserwowanie , klikając prawym przyciskiem myszy identyfikator obiektu i wybierając polecenie Dodaj zegarek.

6. Ustaw kolejny punkt przerwania w metodzie DoSomething() .

7. Kontynuuj debugowanie. Gdy wykonanie zostanie wstrzymane w metodzie DoSomething() , w oknie Obserwowanie zostanie wyświetlony Person obiekt.

   Uwaga

   Jeśli chcesz wyświetlić właściwości obiektu, takie jak Person.Name, musisz włączyć ocenę właściwości, wybierając pozycję Narzędzia>Opcje>Debugowanie>ogólne>Włącz ocenę właściwości i inne niejawne wywołania funkcji.

Widok dynamiczny i okno Obserwowanie

Niektóre języki skryptowe (na przykład JavaScript lub Python) używają dynamicznego lub kaczkowego wpisywania, a platforma .NET w wersji 4.0 lub nowszej obsługuje obiekty, które są trudne do zaobserwowania w normalnych oknach debugowania.

W oknie Obserwowanie są wyświetlane te obiekty jako obiekty dynamiczne, które są tworzone na podstawie typów implementujących IDynamicMetaObjectProvider interfejs. Węzły obiektów dynamicznych pokazują dynamiczne elementy członkowskie obiektów dynamicznych, ale nie zezwalają na edytowanie wartości składowych.

Aby odświeżyć wartości widoku dynamicznego, wybierz ikonę odświeżania obok węzła obiektu dynamicznego.

Aby wyświetlić tylko widok dynamiczny dla obiektu, dodaj specyfikator formatu dynamicznego po nazwie obiektu dynamicznego w oknie Obserwowanie :

• Dla języka C#: ObjectName, dynamic
• Dla języka Visual Basic: $dynamic, ObjectName

Uwaga

• Debuger języka C# nie automatycznie przeszacuje wartości w widoku dynamicznym podczas przechodzenia do następnego wiersza kodu.
• Debuger języka Visual Basic automatycznie odświeża wyrażenia dodane za pośrednictwem widoku dynamicznego.
• Ocena elementów członkowskich widoku dynamicznego może mieć skutki uboczne.

Aby wstawić nową zmienną zegarka, która rzutuje obiekt na obiekt dynamiczny:

1. Kliknij prawym przyciskiem myszy dowolne elementy podrzędne widoku dynamicznego.
2. Wybierz pozycję Dodaj zegarek. Element object.name staje się ((dynamic) object).name wyświetlany w nowym oknie czujki .

Debuger dodaje również węzeł podrzędny Widoku dynamicznego obiektu do okna Autos . Aby otworzyć okno Automatyczne, podczas debugowania wybierz pozycję Debuguj> autos windows.>

Widok dynamiczny rozszerza również debugowanie obiektów COM. Gdy debuger dostaje się do obiektu COM opakowanego w System.__ComObject, dodaje węzeł Widok dynamiczny dla obiektu.

Obserwowanie pojedynczej zmiennej lub wyrażenia za pomocą funkcji QuickWatch

Aby obserwować jedną zmienną, możesz użyć funkcji QuickWatch .

Na przykład dla następującego kodu:

static void Main(string[] args)
{
    int a, b;
    a = 1;
    b = 2;
    for (int i = 0; i < 10; i++)
    {
        a = a + b;
    }
}

Aby obserwować zmienną a ,

1. Ustaw punkt przerwania w a = a + b; wierszu.

2. Uruchom debugowanie. Wykonywanie wstrzymuje się w punkcie przerwania.

3. Wybierz zmienną a w kodzie.

4. Wybierz pozycję Debuguj>QuickWatch, naciśnij klawisze Shift+F9 lub kliknij prawym przyciskiem myszy i wybierz pozycję QuickWatch.

   Zostanie wyświetlone okno dialogowe QuickWatch . Zmienna a znajduje się w polu Wyrażenie z wartością 1.

   

5. Aby ocenić wyrażenie przy użyciu zmiennej, wpisz wyrażenie, takie jak a + b w polu Wyrażenie, a następnie wybierz pozycję Przeszacuj.

   

6. Aby dodać zmienną lub wyrażenie z aplikacji QuickWatch do okna Watch , wybierz pozycję Dodaj zegarek.

7. Wybierz pozycję Zamknij , aby zamknąć okno QuickWatch . (QuickWatch to modalne okno dialogowe, więc nie można kontynuować debugowania tak długo, jak jest otwarte).

8. Kontynuuj debugowanie. Zmienną można obserwować w oknie Obserwowanie .

Powiązana zawartość

• Co to jest debugowanie?
• Techniki debugowania i narzędzia
• Pierwsze spojrzenie na debugowanie
• Okna debugera