Verwenden von Trace- und Debugklassen in Visual Basic .NET

  • Artikel
  • 8 Minuten Lesedauer

Dieser Artikel enthält Informationen zur Verwendung der Debug Klassen in Trace Visual Basic .NET.

Originalversion des Produkts:   Visual Basic .NET
Ursprüngliche KB-Nummer:   313417

Zusammenfassung

In diesem Artikel wird die Verwendung der Debug Klassen und der Trace Klassen veranschaulicht. Diese Klassen sind im Microsoft .NET Framework verfügbar. Sie können diese Klassen verwenden, um Informationen über die Leistung einer Anwendung entweder während der Anwendungsentwicklung oder nach der Bereitstellung in der Produktion bereitzustellen. Diese Klassen sind nur ein Teil der Instrumentierungsfeatures, die im .NET Framework verfügbar sind.

Anforderungen

In der folgenden Liste sind die empfohlenen Hardware, Software, Netzwerkinfrastruktur und Service Packs aufgeführt, die Sie benötigen:

  • Windows
  • Visual Basic .NET

In diesem Artikel wird auch davon ausgegangen, dass Sie mit dem Programmdebugging vertraut sind.

Beschreibung der Technik

Die Schritte im Abschnitt "Erstellen eines Beispiels mit der Debugklasse " veranschaulichen das Erstellen einer Konsolenanwendung, die die Debug Klasse verwendet, um Informationen zur Programmausführung bereitzustellen.

Wenn das Programm ausgeführt wird, können Sie Methoden der Debug Klasse verwenden, um Nachrichten zu erstellen, die zur Überwachung, zur Erkennung von Fehlfunktionen oder zur Bereitstellung von Leistungsmessinformationen beitragen. Standardmäßig werden die von der Debug Klasse erzeugten Meldungen im Ausgabefenster der Microsoft Visual Studio Integrated Development Environment (IDE) angezeigt.

Der Beispielcode verwendet die WriteLine Methode, um eine Nachricht zu erzeugen, auf die ein Zeilenabschlusszeichen folgt. Wenn Sie diese Methode verwenden, um eine Nachricht zu erzeugen, wird jede Nachricht in einer separaten Zeile im Ausgabefenster angezeigt.

Wenn Sie die Assert Methode der Debug Klasse verwenden, wird im Ausgabefenster nur dann eine Meldung angezeigt, wenn eine angegebene Bedingung als falsch ausgewertet wird. Die Meldung wird dem Benutzer auch in einem modalen Dialogfeld angezeigt. Das Dialogfeld enthält die Nachricht, den Projektnamen und die Debug.Assert Anweisungsnummer. Das Dialogfeld enthält außerdem drei Befehlsschaltflächen:

  • Abbrechen: Die Anwendung wird nicht mehr ausgeführt.
  • Wiederholung: Die Anwendung wechselt in den Debugmodus.
  • Ignorieren: Die Anwendung fährt fort. Der Benutzer muss auf eine dieser Schaltflächen klicken, bevor die Anwendung fortgesetzt werden kann.

Sie können die Debug Ausgabe der Klasse auch an andere Ziele als das Ausgabefenster weiterleiten. Die Debug Klasse verfügt über eine Auflistung mit dem Namen Listeners Listener-Objekte. Jedes Listener-Objekt überwacht Debug die Ausgabe und leitet die Ausgabe an ein angegebenes Ziel weiter. Jeder Listener in der Listeners Auflistung empfängt eine von der Debug Klasse generierte Ausgabe. Verwenden Sie die TextWriterTraceListener Klasse, um Listener-Objekte zu definieren. Sie können das Ziel für eine TextWriterTraceListener Klasse über ihren Konstruktor angeben. Einige mögliche Ausgabeziele sind:

  • Das Konsolenfenster mithilfe der System.Console.Out Eigenschaft.
  • Eine Textdatei mithilfe der System.IO.File.CreateText("FileName.txt")) Anweisung.

Nachdem Sie ein TextWriterTraceListener Objekt erstellt haben, müssen Sie das Objekt der Auflistung hinzufügen, um die Debug.Listeners Ausgabe zu erhalten Debug .

Erstellen eines Beispiels mit der Debugklasse

  1. Verwenden Sie Visual Basic .NET, um ein neues Konsolenanwendungsprojekt namens "conInfo" zu erstellen. Ein öffentliches Modul mit dem Namen Module1 wird dem Projekt standardmäßig hinzugefügt.

  2. Fügen Sie die folgenden Dim Anweisungen hinzu, um Variablen zu initialisieren, die Informationen zu einem Produkt enthalten:

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

  3. Geben Sie die Meldung an, die von der Klasse als erster Eingabeparameter der WriteLine Methode erzeugt wird. Drücken Sie DIE TASTENkombination STRG+ALT+O, um sicherzustellen, dass das Ausgabefenster sichtbar ist.

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

  4. Verwenden Sie zur besseren Lesbarkeit die Indent Methode, um nachfolgende Nachrichten im Ausgabefenster einzurücken:

    Debug.Indent()

  5. Um den Inhalt ausgewählter Variablen anzuzeigen, verwenden Sie die WriteLine Methode wie folgt:

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

  6. Sie können die WriteLine Methode auch verwenden, um den Namespace und den Klassennamen für ein vorhandenes Objekt anzuzeigen. Der folgende Code zeigt z. B. den System.Xml.XmlDocument Namespace im Ausgabefenster an:

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

  7. Zum Organisieren der Ausgabe können Sie eine Kategorie als optionalen zweiten Eingabeparameter der WriteLine Methode einschließen. Wenn Sie eine Kategorie angeben, lautet das Format der Ausgabefensternachricht "Kategorie: Nachricht". In der ersten Zeile des folgenden Codes wird beispielsweise im Ausgabefenster "Feld: Der Produktname ist Widget" angezeigt:

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

  8. Im Ausgabefenster können Meldungen nur angezeigt werden, wenn eine festgelegte Bedingung mithilfe der WriteLineIf Methode der Debug Klasse als wahr ausgewertet wird. Die auszuwertende Bedingung ist der erste Eingabeparameter der WriteLineIf Methode. Der zweite Parameter ist WriteLineIf die Meldung, die nur angezeigt wird, wenn die Bedingung im ersten Parameter als wahr ausgewertet wird.

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

  9. Verwenden Sie die Assert-Methode der Debug Klasse, damit die Meldung im Ausgabefenster nur angezeigt wird, wenn eine angegebene Bedingung als "false" ausgewertet wird:

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

  10. Erstellen Sie die TextWriterTraceListener Objekte für das Konsolenfenster (tr1) und für eine Textdatei mit dem Namen Output.txt (tr2), und fügen Sie dann jedes Objekt der Debug Listeners Auflistung hinzu:

    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)

  11. Verwenden Sie zur besseren Lesbarkeit die Unindent Methode, um den Einzug für nachfolgende Nachrichten zu entfernen, die von der Debug Klasse generiert werden. Wenn Sie die Methoden und die Indent Unindent Methoden zusammen verwenden, kann der Leser die Ausgabe als Gruppe unterscheiden.

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

  12. Um sicherzustellen, dass jedes Listener-Objekt die gesamte Ausgabe empfängt, rufen Sie die Flush Methode für die Debug Klassenpuffer auf:

    Debug.Flush()

Verwenden der Trace-Klasse

Sie können die Trace Klasse auch verwenden, um Nachrichten zu erstellen, die die Ausführung einer Anwendung überwachen. Die Trace Klassen und Debug klassen verwenden die meisten der gleichen Methoden, um eine Ausgabe zu erzeugen, einschließlich:

  • WriteLine
  • WriteLineIf
  • Indent
  • Unindent
  • Assert
  • Flush

Sie können die Trace Klassen und die Debug Klassen separat oder zusammen in derselben Anwendung verwenden. In einem Debuglösungskonfigurationsprojekt sind sowohl die Ausgabe als auch Trace Debug die Ausgabe aktiv. Das Projekt generiert die Ausgabe dieser beiden Klassen für alle Listener-Objekte. Ein Projekt zur Versionslösungskonfiguration generiert jedoch nur die Ausgabe einer Trace Klasse. Das Projekt "Release Solution Configuration" ignoriert alle Debug Klassenmethodenaufrufe.

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

Überprüfen, ob es funktioniert

  1. Stellen Sie sicher, dass Debuggen die aktuelle Lösungskonfiguration ist.

  2. Wenn das Projektmappen-Explorer Fenster nicht sichtbar ist, drücken Sie die Tastenkombination STRG+ALT+L, um dieses Fenster anzuzeigen.

  3. Klicken Sie mit der rechten Maustaste auf "conInfo", und klicken Sie dann auf "Eigenschaften".

  4. Stellen Sie im linken Bereich der Eigenschaftenseite "conInfo " unter dem Ordner "Konfiguration " sicher, dass der Pfeil auf "Debuggen" zeigt.

  5. Klicken Sie oberhalb des Ordners "Konfiguration " im Dropdown-Listenfeld "Konfiguration" auf "Aktiv" (Debuggen) oder " Debuggen", und klicken Sie dann auf "OK".

  6. Drücken Sie STRG+ALT+O, um das Ausgabefenster anzuzeigen.

  7. Drücken Sie F5, um den Code auszuführen. Wenn das Dialogfeld "Assertion Failed" angezeigt wird, klicken Sie auf "Ignorieren".

  8. Drücken Sie im Konsolenfenster die EINGABETASTE. Das Programm sollte fertig sein, und im Ausgabefenster sollte die folgende Ausgabe angezeigt werden:

    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

  9. Im Konsolenfenster und in der Output.txt Datei sollte die folgende Ausgabe angezeigt werden:

    (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

Vollständige Codeauflistung

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

Problembehandlung

  • Wenn der Lösungskonfigurationstyp "Release" lautet, wird die Debug Klassenausgabe ignoriert.

  • Nachdem Sie eine TextWriterTraceListener Klasse für ein bestimmtes Ziel erstellt haben, TextWriterTraceListener empfängt die Ausgabe von der Trace und den Debug Klassen. Dies geschieht unabhängig davon, ob Sie die Add Methode der Trace Klasse oder die Debug Klasse verwenden, um sie der Listeners Klasse hinzuzufügenTextWriterTraceListener.

  • Wenn Sie ein Listener-Objekt für dasselbe Ziel in der Trace und den Debug Klassen hinzufügen, wird jede Ausgabezeile dupliziert, unabhängig davon, ob Debug die Ausgabe generiert oder Trace generiert wird.

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

References