Używanie klas Trace and Debug w programie Visual Basic .NET

Ten artykuł zawiera informacje o sposobie używania Debug klas i Trace w języku Visual Basic .NET.

Oryginalna wersja produktu: Visual Basic .NET
Oryginalny numer KB: 313417

Podsumowanie

W tym artykule pokazano, jak używać Debug klas i Trace . Te klasy są dostępne w programie Microsoft .NET Framework. Za pomocą tych klas można podać informacje o wydajności aplikacji podczas tworzenia aplikacji lub po wdrożeniu do środowiska produkcyjnego. Te klasy są tylko jedną częścią funkcji instrumentacji, które są dostępne w programie .NET Framework.

Wymagania

Na poniższej liście przedstawiono zalecany sprzęt, oprogramowanie, infrastrukturę sieciową i wymagane dodatki Service Pack:

Windows
Visual Basic .NET

W tym artykule założono również, że znasz debugowanie programów.

Opis techniki

Kroki opisane w sekcji Tworzenie przykładu w sekcji Klasa debugowania pokazują, jak utworzyć aplikację konsolową, która używa Debug klasy do dostarczania informacji o wykonaniu programu.

Po uruchomieniu programu można użyć metod Debug klasy do tworzenia komunikatów, które pomagają monitorować, wykrywać awarie lub dostarczać informacje o pomiarze wydajności. Domyślnie komunikaty generowane Debug przez klasę są wyświetlane w oknie Dane wyjściowe zintegrowanego środowiska projektowego (IDE) programu Microsoft Visual Studio.

Przykładowy kod używa WriteLine metody do utworzenia komunikatu, po którym następuje terminator wiersza. Gdy używasz tej metody do tworzenia komunikatu, każdy komunikat pojawia się w osobnym wierszu w oknie Dane wyjściowe.

Jeśli używasz Assert metody Debug klasy, w oknie Dane wyjściowe zostanie wyświetlony komunikat tylko wtedy, gdy określony warunek zwróci wartość false. Komunikat jest również wyświetlany w modalnym oknie dialogowym dla użytkownika. Okno dialogowe zawiera komunikat, nazwę projektu i numer instrukcji Debug.Assert . Okno dialogowe zawiera również trzy przyciski poleceń:

Przerwanie: aplikacja przestaje działać.
Ponów próbę: aplikacja wprowadza tryb debugowania.
Ignoruj: aplikacja jest kontynuowana. Użytkownik musi kliknąć jeden z tych przycisków, zanim aplikacja będzie mogła kontynuować.

Możesz również kierować dane wyjściowe z Debug klasy do miejsc docelowych innych niż okno Dane wyjściowe. Klasa Debug ma kolekcję o nazwie Listeners , która zawiera obiekty odbiornika. Każdy obiekt Odbiornik monitoruje Debug dane wyjściowe i kieruje dane wyjściowe do określonego obiektu docelowego. Każdy odbiornik w Listeners kolekcji otrzymuje wszystkie dane wyjściowe generowane przez klasę Debug . TextWriterTraceListener Użyj klasy , aby zdefiniować obiekty odbiornika. Element docelowy klasy można określić za pomocą konstruktora TextWriterTraceListener . Niektóre możliwe elementy docelowe danych wyjściowych to:

Okno Konsola przy użyciu System.Console.Out właściwości .
Plik tekstowy przy użyciu instrukcji System.IO.File.CreateText("FileName.txt")) .

Po utworzeniu TextWriterTraceListener obiektu należy dodać obiekt do kolekcji w celu odbierania Debug.Listeners Debug danych wyjściowych.

Tworzenie przykładu przy użyciu klasy Debug

Użyj programu Visual Basic .NET, aby utworzyć nowy projekt aplikacji konsolowej o nazwie conInfo. Domyślnie do projektu jest dodawany publiczny moduł o nazwie Module1 .

Aby zainicjować zmienne zawierające informacje o produkcie, dodaj następujące Dim instrukcje:

Dim sProdName As String = "Widget"
Dim iUnitQty As Integer = 100
Dim dUnitCost As Decimal = 1.03

Określ komunikat, który klasa generuje jako pierwszy parametr WriteLine wejściowy metody. Naciśnij kombinację CTRL+ALT+O, aby upewnić się, że okno Dane wyjściowe jest widoczne.
```
Debug.WriteLine("Debug Information-Product Starting ")
```
Aby uzyskać czytelność, użyj Indent metody , aby wciąć kolejne komunikaty w oknie Dane wyjściowe:
```
Debug.Indent()
```

Aby wyświetlić zawartość wybranych zmiennych, użyj WriteLine metody w następujący sposób:

Debug.WriteLine("The product name is " & sProdName)
Debug.WriteLine("The available units on hand are " & iUnitQty)
Debug.WriteLine("The per unit cost is " & dUnitCost)

Można również użyć WriteLine metody , aby wyświetlić przestrzeń nazw i nazwę klasy dla istniejącego obiektu. Na przykład poniższy kod wyświetla System.Xml.XmlDocument przestrzeń nazw w oknie Dane wyjściowe:
```
Dim oxml As New System.Xml.XmlDocument()
Debug.WriteLine(oxml)
```
Aby zorganizować dane wyjściowe, możesz dołączyć kategorię jako opcjonalny, drugi parametr WriteLine wejściowy metody. Jeśli określisz kategorię, format komunikatu okna Dane wyjściowe to "kategoria: komunikat". Na przykład w pierwszym wierszu następującego kodu zostanie wyświetlony komunikat "Pole: Nazwa produktu to Widget" w oknie Dane wyjściowe:
```
Debug.WriteLine("The product name is " & sProdName, "Field")
Debug.WriteLine("The units on hand are " & iUnitQty, "Field")
Debug.WriteLine("The per unit cost is " & dUnitCost, "Field")
Debug.WriteLine("Total Cost is" & iUnitQty * dUnitCost, "Calc")
```
Okno Dane wyjściowe może wyświetlać komunikaty tylko wtedy, gdy wyznaczony warunek daje wartość true przy użyciu WriteLineIf metody Debug klasy . Warunek, który ma zostać oceniony, jest pierwszym parametrem wejściowym WriteLineIf metody. Drugi parametr WriteLineIf to komunikat, który pojawia się tylko wtedy, gdy warunek w pierwszym parametrze ma wartość true.
```
Debug.WriteLineIf(iUnitQty > 50, "This message WILL appear")
Debug.WriteLineIf(iUnitQty < 50, "This message will NOT appear")
```
Użyj metody Debug Assert klasy, aby okno Dane wyjściowe wyświetlało komunikat tylko wtedy, gdy określony warunek daje wartość false:
```
Debug.Assert(dUnitCost > 1, "Message will NOT appear")
Debug.Assert(dUnitCost < 1, "Message will appear")
```

TextWriterTraceListener Utwórz obiekty dla okna Konsoli (tr1) i pliku tekstowego o nazwie Output.txt (tr2), a następnie dodaj każdy obiekt do Debug Listeners kolekcji:

Dim tr1 As New TextWriterTraceListener(System.Console.Out)
Debug.Listeners.Add(tr1)

Dim tr2 As New _
    TextWriterTraceListener(System.IO.File.CreateText("Output.txt"))
Debug.Listeners.Add(tr2)

Aby uzyskać czytelność, użyj Unindent metody , aby usunąć wcięcia dla kolejnych komunikatów generowanych przez klasę Debug . W przypadku używania Indent metod i Unindent czytnik może odróżnić dane wyjściowe jako grupę.
```
Debug.Unindent()
Debug.WriteLine("Debug Information-Product Ending")
```
Aby upewnić się, że każdy obiekt Odbiornik odbiera wszystkie jego dane wyjściowe, wywołaj metodę Flush Debug klas:
```
Debug.Flush()
```

Korzystanie z klasy Trace

Możesz również użyć Trace klasy do tworzenia komunikatów monitorujących wykonywanie aplikacji. Klasy Trace i Debug współużytkują większość tych samych metod w celu wygenerowania danych wyjściowych, w tym:

WriteLine
WriteLineIf
Indent
Unindent
Assert
Flush

Klasy i Debug można używać Trace oddzielnie lub razem w tej samej aplikacji. W projekcie Konfiguracja rozwiązania debugowania dane wyjściowe i Debug są Trace aktywne. Projekt generuje dane wyjściowe z obu tych klas do wszystkich obiektów Odbiornik. Jednak projekt Release Solution Configuration generuje tylko dane wyjściowe z Trace klasy. Projekt Release Solution Configuration ignoruje wszystkie Debug wywołania metody klasy.

Trace.WriteLine("Trace Information-Product Starting ")
Trace.Indent()

Trace.WriteLine("The product name is " & sProdName)
Trace.WriteLine("The product name is " & sProdName, "Field")
Trace.WriteLineIf(iUnitQty > 50, "This message WILL appear")
Trace.Assert(dUnitCost > 1, "Message will NOT appear")

Trace.Unindent()
Trace.WriteLine("Trace Information-Product Ending")
Trace.Flush()
Console.ReadLine()

Sprawdź, czy działa

Upewnij się, że debugowanie jest bieżącą konfiguracją rozwiązania.
Jeśli okno Eksplorator rozwiązań nie jest widoczne, naciśnij kombinację CTRL+ALT+L, aby wyświetlić to okno.
Kliknij prawym przyciskiem myszy polecenie conInfo, a następnie kliknij polecenie Właściwości.
W lewym okienku strony właściwości conInfo w folderze Konfiguracja upewnij się, że strzałka wskazuje pozycję Debugowanie.
Nad folderem Konfiguracja w polu listy rozwijanej Konfiguracja kliknij pozycję Aktywne (debugowanie) lub Debuguj, a następnie kliknij przycisk OK.
Naciśnij CTRL+ALT+O, aby wyświetlić okno Dane wyjściowe.
Naciśnij F5, aby uruchomić kod. Gdy pojawi się okno dialogowe Asercji nie powiodło się, kliknij przycisk Ignoruj.

W oknie Konsola naciśnij ENTER. Program powinien zostać zakończony, a w oknie Dane wyjściowe powinny zostać wyświetlone następujące dane wyjściowe:

Debug Information-Product Starting
    The product name is Widget
    The available units on hand are 100
    The per unit cost is 1.03
    System.Xml.XmlDocument
    Field: The product name is Widget
    Field: The units on hand are 100
    Field: The per unit cost is 1.03
    Calc: Total cost is 103
    This message WILL appear
    ---- DEBUG ASSERTION FAILED ----
---- Assert Short Message ----
Message will appear
---- Assert Long Message ----

at Module1.Main() C:\Documents and Settings\Administrator\My
Documents\Visual Studio Projects\conInfo\Module1.vb(29)

    The product name is Widget
    The available units on hand are 100
    The per unit cost is 1.03
Debug Information-Product Ending
Trace Information-Product Starting
    The product name is Widget
    Field: The product name is Widget
    This message WILL appear
Trace Information-Product Ending

W oknie Konsola i w pliku Output.txt powinny zostać wyświetlone następujące dane wyjściowe:

(The Output.txt file is located in the same directory as the conInfo
executable, conInfo.exe. Normally this is the \bin folder of where the
project source has been stored. By default that would be C:\Documents and
Settings\User login\My Documents\Visual Studio Projects\conInfo\bin)
    The product name is Widget
    The available units on hand are 100
    The per unit cost is 1.03
Debug Information-Product Ending
Trace Information-Product Starting
    The product name is Widget
    Field: The product name is Widget
    This message WILL appear
Trace Information-Product Ending

Kompletna lista kodu

Module Module1
    Sub Main()
        Dim sProdName As String = "Widget"
        Dim iUnitQty As Integer = 100
        Dim dUnitCost As Decimal = 1.03

        Debug.WriteLine("Debug Information-Product Starting ")
        Debug.Indent()

        Debug.WriteLine("The product name is " & sProdName)
        Debug.WriteLine("The available units on hand are " & iUnitQty)
        Debug.WriteLine("The per unit cost is " & dUnitCost)

        Dim oxml As New System.Xml.XmlDocument()
        Debug.WriteLine(oxml)

        Debug.WriteLine("The product name is " & sProdName, "Field")
        Debug.WriteLine("The units on hand are " & iUnitQty, "Field")
        Debug.WriteLine("The per unit cost is " & dUnitCost, "Field")
        Debug.WriteLine("Total cost is " & iUnitQty * dUnitCost, "Calc")

        Debug.WriteLineIf(iUnitQty > 50, "This message WILL appear")
        Debug.WriteLineIf(iUnitQty < 50, "This message will NOT appear")

        Debug.Assert(dUnitCost > 1, "Message will NOT appear")
        Debug.Assert(dUnitCost < 1, "Message will appear")

        Dim tr1 As New TextWriter`Trace`Listener(System.Console.Out)
        Debug.Listeners.Add(tr1)

        Dim tr2 As New _
            TextWriterTraceListener(System.IO.File.CreateText("Output.txt"))

        Debug.Listeners.Add(tr2)

        Debug.WriteLine("The product name is " & sProdName)
        Debug.WriteLine("The available units on hand are " & iUnitQty)
        Debug.WriteLine("The per unit cost is " & dUnitCost)

        Debug.Unindent()
        Debug.WriteLine("Debug Information-Product Ending")

        Debug.Flush()

        Trace.WriteLine("`Trace` Information-Product Starting ")

        Trace.Indent()

        Trace.WriteLine("The product name is " & sProdName)
        Trace.WriteLine("The product name is " & sProdName, "Field")
        Trace.WriteLineIf(iUnitQty > 50, "This message WILL appear")
        Trace.Assert(dUnitCost > 1, "Message will NOT appear")

        Trace.Unindent()
        Trace.WriteLine("Trace Information-Product Ending")

        Trace.Flush()

        Console.ReadLine()
    End Sub
End Module

Rozwiązywanie problemów

Jeśli typ konfiguracji rozwiązania to Release, Debug dane wyjściowe klasy są ignorowane.
Po utworzeniu TextWriterTraceListener klasy dla określonego obiektu docelowego TextWriterTraceListener odbiera dane wyjściowe z Trace klas i Debug . Dzieje się tak niezależnie od tego, czy używasz Add metody Trace klasy , czy Debug klasy do dodania Listeners TextWriterTraceListener do klasy.
Jeśli dodasz obiekt Listener dla tego samego obiektu docelowego w Trace klasach i Debug , każdy wiersz danych wyjściowych zostanie zduplikowany, niezależnie od tego, czy Debug lub Trace generuje dane wyjściowe.
```
Dim tr1 As New TextWriterTraceListener(System.Console.Out)
Debug.Listeners.Add(tr1)
Dim tr2 As New TextWriterTraceListener(System.Console.Out)
Trace.Listeners.Add(tr2)
```

Informacje

Opinia

Czy ta strona była pomocna?

Last updated on 2024-07-30