DetailPage-MSS-KB

Knowledge Base

Artikel-ID: 313417 - Geändert am: Sonntag, 13. Mai 2007 - Version: 1.3

Dieser Artikel wurde zuvor veröffentlicht unter D313417
Dieser Artikel ist eine Übersetzung des folgenden englischsprachigen Artikels der Microsoft Knowledge Base:
313417  (http://support.microsoft.com/kb/313417/en-us/ ) HOW TO: Trace and Debug in Visual Basic .NET
Eine Microsoft Visual Basic 6.0 Version dieses Artikels finden Sie unter 161153  (http://support.microsoft.com/kb/161153/DE/ ) .
Bitte beachten Sie: Bei diesem Artikel handelt es sich um eine Übersetzung aus dem Englischen. Es ist möglich, dass nachträgliche Änderungen bzw. Ergänzungen im englischen Originalartikel in dieser Übersetzung nicht berücksichtigt sind. Die in diesem Artikel enthaltenen Informationen basieren auf der/den englischsprachigen Produktversion(en). Die Richtigkeit dieser Informationen in Zusammenhang mit anderssprachigen Produktversionen wurde im Rahmen dieser Übersetzung nicht getestet. Microsoft stellt diese Informationen ohne Gewähr für Richtigkeit bzw. Funktionalität zur Verfügung und übernimmt auch keine Gewährleistung bezüglich der Vollständigkeit oder Richtigkeit der Übersetzung.

Auf dieser Seite

Zusammenfassung

Dieser Artikel beschreibt die Verwendung der Klassen Debug und Trace. Diese Klassen stehen im Microsoft .NET Framework zur Verfügung. Sie können diese Klassen dazu verwenden, Informationen über die Leistung einer Anwendung während der Anwendungsentwicklung oder im Produktiveinsatz bereitzustellen. Diese Klassen sind nur ein Teil der Instrumentierungsfeatures im .NET Framework.

Voraussetzungen

In der folgenden Liste sind die empfohlene Hardware, Software, Netzwerkinfrastruktur und die erforderlichen Service Packs aufgeführt:
  • Microsoft Windows 2000 oder Microsoft Windows XP
  • Microsoft Visual Basic .NET
Dieser Artikel setzt voraus, dass Sie mit dem Debuggen von Programmen vertraut sind.

Hinweis: Die Verwendung der hier aufgeführten Informationen sowie Makro- oder Programmcodes geschieht auf Ihre eigene Verantwortung. Microsoft stellt Ihnen diese Informationen sowie Makro- und Programmlistings ohne Gewähr auf Richtigkeit, Vollständigkeit und/oder Funktionalität sowie ohne Anspruch auf Support zur Verfügung. Die zur Verfügung gestellten Makro- und Programmierungsbeispiele sollen lediglich exemplarisch die Funktionsweise des Beispiels aufzeigen.

Beschreibung der Technik

Die Schritte im Abschnitt Erstellen eines Beispiels mit der Klasse "Debug" zeigen, wie man eine Konsolenanwendung erstellt, die über die Klasse Debug Informationen über die Programmausführung liefert.

Bei Ausführung des Programms können Sie Methoden der Klasse Debug verwenden, um Meldungen zu erzeugen, die die Überwachung und Erkennung von Fehlern unterstützen oder Informationen zur Leistungsmessung liefern. Standardmäßig erscheinen die von der Klasse Debug erzeugten Meldungen im Ausgabefenster der integrierten Entwicklungsumgebung von Visual Studio (IDE = Integrated Development Environment).

Im Beispielcode wird die Methode WriteLine verwendet, um eine Meldung zu erzeugen, der ein Zeilenabschlusszeichen folgt. Wenn Sie mit dieser Methode eine Meldung erzeugen, erscheint jede Meldung in einer separaten Zeile im Ausgabefenster.

Wenn Sie die Methode Assert der Klasse Debug verwenden, zeigt das Ausgabefenster nur dann eine Meldung an, wenn die Prüfung einer bestimmten Bedingung "falsch" ergibt. Die Meldung wird dem Benutzer auch in einem modalen Dialogfeld angezeigt. Das Dialogfeld enthält die Meldung, den Projektnamen und die Nummer der Debug.Assert-Anweisung. Das Dialogfeld enthält außerdem drei Befehlsschaltflächen:
  • Abbrechen: Die Anwendung wird abgebrochen.
  • Wiederholen: Die Anwendung geht in den Debugmodus.
  • Ignorieren: Die Anwendung läuft weiter.
Der Benutzer muss eine dieser Schaltflächen anklicken, damit die Anwendung fortgesetzt werden kann.

Sie können für Ausgaben der Klasse Debug auch andere Ziele als das Ausgabefenster vorsehen. Die Klasse Debug hat eine Auflistung namens Listeners, die Listener-Objekte enthält. Jedes Listener-Objekt überwacht Debug-Ausgaben und leitet sie zu einem vorgegebenen Ziel. Jeder Listener in der Auflistung Listeners empfängt jegliche Ausgabe, die die Klasse Debug erzeugt. Verwenden Sie die Klasse TextWriterTraceListener, um Listener-Objekte zu definieren. Sie können das Ziel für eine TextWriterTraceListener-Klasse über ihren Konstruktor angeben. Zu den möglichen Ausgabezielen gehören:
  • das Konsolenfenster über die Eigenschaft System.Console.Out.
  • eine Textdatei (.txt) über die Anweisung System.IO.File.CreateText("Dateiname.txt"))
Nachdem Sie ein TextWriterTraceListener-Objekt erstellt haben, müssen Sie es zur Auflistung Debug.Listeners hinzufügen, um Debug-Ausgaben zu erhalten.

Erstellen eines Beispiels mit der Klasse "Debug"

  1. Starten Sie Visual Studio .NET.
  2. Erstellen Sie ein neues Konsolenanwendungsprojekt namens "conInfo" in Visual Basic .NET. Ein öffentliches Modul namens "Module1" wird standardmäßig zum Projekt hinzugefügt.
  3. Fügen Sie die folgenden Dim-Anweisungen hinzu, um Variablen zu initialisieren, die Produktinformationen enthalten sollen:
    Dim sProdName As String = "Widget"
    Dim iUnitQty As Integer = 100
    Dim dUnitCost As Decimal = 1.03
  4. Geben Sie die Meldung an, die die Klasse als ersten Eingabeparameter der Methode WriteLine erzeugt. Drücken Sie die Tastenkombination [STRG]+[ALT]+[O], um sicherzustellen, dass das Ausgabefenster angezeigt wird.
    Debug.WriteLine("Debug Information-Product Starting ")
  5. Verwenden Sie zur besseren Lesbarkeit die Methode Indent, um nachfolgende Meldungen im Ausgabefenster einzuziehen:
    Debug.Indent()
  6. Verwenden Sie die Methode WriteLine folgendermaßen, um den Inhalt ausgewählter Variablen anzuzeigen:
    Debug.WriteLine("The product name is " & sProdName)
    Debug.WriteLine("The available units on hand are " & iUnitQty)
    Debug.WriteLine("The per unit cost is " & dUnitCost)
  7. Sie können die Methode WriteLine auch dazu verwenden, den Namespace und Klassennamen für ein vorhandenes Objekt anzuzeigen. Der folgende Code zeigt z.B. den Namespace System.Xml.XmlDocument im Ausgabefenster an:
    Dim oxml As New System.Xml.XmlDocument()
    Debug.WriteLine(oxml)
  8. Um die Ausgabe anzuordnen, können Sie eine Kategorie als optionalen zweiten Eingabeparameter der Methode WriteLine hinzunehmen. Wenn Sie eine Kategorie angeben, ist das Format der Meldung im Ausgabefenster "Kategorie: Meldung". Die erste Zeile des folgenden Code zeigt z.B. "Field: The product name is Widget" im Ausgabefenster an:
    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")
  9. Das Ausgabefenster kann Meldungen nur dann anzeigen, wenn die Prüfung einer dazu vorgesehenen Bedingung über die Methode WriteLineIf der Klasse Debug "wahr" ergibt. Die auszuwertende Bedingung ist der erste Eingabeparameter der Methode WriteLineIf. Der zweite Parameter von WriteLineIf ist die Meldung, die nur dann erscheint, wenn die Prüfung der Bedingung im ersten Parameter "wahr" ergibt.
    Debug.WriteLineIf(iUnitQty > 50, "This message WILL appear")
    Debug.WriteLineIf(iUnitQty < 50, "This message will NOT appear")
  10. Verwenden Sie die Methode Assert der Klasse Debug, damit das Ausgabefenster nur dann eine Meldung anzeigt, wenn die Prüfung einer bestimmten Bedingung "falsch" ergibt:
    Debug.Assert(dUnitCost > 1, "Message will NOT appear")
    Debug.Assert(dUnitCost < 1, "Message will appear")
  11. Erstellen Sie die TextWriterTraceListener-Objekte für das Konsolenfenster (tr1) und für eine Textdatei namens "Output.txt" (tr2). Fügen Sie die Objekte dann zur Auflistung Debug Listeners 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)
  12. Verwenden Sie zur besseren Lesbarkeit die Methode Unindent, um den Einzug für die nachfolgenden Meldungen zu entfernen, die von der Klasse Debug erzeugt werden. Wenn Sie die Methoden Indent und Unindent zusammen verwenden, kann der Leser die Ausgabe als Gruppe identifizieren.
    Debug.Unindent()
    Debug.WriteLine("Debug Information-Product Ending")
  13. Rufen Sie die Methode Flush für die Puffer der Klasse Debug auf, um zu gewährleisten, dass jedes Listener-Objekt all seine Ausgaben erhält:
    Debug.Flush()

Verwendung der Klasse "Trace"

Sie können auch mit der Klasse Trace Meldungen erzeugen, die die Ausführung einer Anwendung überwachen. Die Klassen Trace und Debug nutzen die meisten Methoden zur Erzeugung von Ausgaben gemeinsam. Dazu gehören:
  • WriteLine
  • WriteLineIf
  • Indent
  • Unindent
  • Assert
  • Flush
Sie können die Klassen Trace und Debug separat oder zusammen in derselben Anwendung nutzen. In einem Debug-Projektmappen-Konfigurationsprojekt sind sowohl Trace- als auch Debug-Ausgaben aktiv. Das Projekt generiert aus beiden Klassen Ausgaben für alle Listener-Objekte. Ein Release-Projektmappen-Konfigurationsprojekt erzeugt jedoch nur aus einer Trace-Klasse eine Ausgabe. Das Release-Projektmappen-Konfigurationsprojekt ignoriert jegliche Methodenaufrufe der Klasse Debug.
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 der Funktionsfähigkeit

  1. Stellen Sie sicher, dass Debug die aktuelle Projektmappenkonfiguration ist.
  2. Wenn das Fenster des Projektmappen-Explorer nicht angezeigt wird, drücken Sie die Tastenkombination [STRG]+[ALT]+[L], um das Fenster anzuzeigen.
  3. Klicken Sie mit der rechten Maustaste auf conInfo. Klicken Sie dannn auf Eigenschaften.
  4. Vergewissern Sie sich, dass der Pfeil im linken Fenster der conInfo-Eigenschaftenseite unter dem Konfigurationsordner auf Debuggen zeigt.
  5. Klicken Sie über dem Konfigurationsordner im Dropdown-Listenfeld Konfiguration auf Aktiv (Debuggen) oder Debuggen. 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 erscheint, klicken Sie auf Ignorieren.
  8. Drücken Sie im Konsolenfenster die EINGABETASTE. Jetzt sollte das Programm beendet werden, und im Ausgabefenster sollte folgende Ausgabe erscheinen:
    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. Das Konsolenfenster und die Datei "Output.txt" sollten folgende Ausgabe anzeigen:
    (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ändiges Codelisting

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 TextWriterTraceListener(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 Projektmappenkonfigurationstyp Herausgeben ist, wird die Ausgabe der Klasse Debug ignoriert.
  • Nachdem Sie eine Klasse TextWriterTraceListener für ein bestimmtes Ziel erstellt haben, empfängt TextWriterTraceListener Ausgaben der Klassen Trace und Debug. Das geschieht unabhängig davon, ob Sie die Methode Add der Klasse Trace oder Debug verwenden, um TextWriterTraceListener zur Klasse Listeners hinzuzufügen.
  • Wenn Sie ein Listener-Objekt für dasselbe Ziel in den Klassen Trace und Debug hinzufügen, wird jede Ausgabezeile dupliziert, unabhängig davon, ob Debug oder Trace die Ausgabe erzeugt.
    Dim tr1 As New TextWriterTraceListener(System.Console.Out)
    Debug.Listeners.Add(tr1)
    Dim tr2 As New TextWriterTraceListener(System.Console.Out)
    Trace.Listeners.Add(tr2)

Informationsquellen

Weitere Informationen finden Sie unter folgenden Themen in der Dokumentation der .NET Framework-Klassenbibliothek:
Trace Class
http://msdn2.microsoft.com/en-us/library/system.diagnostics.trace(vs.71).aspx (http://msdn2.microsoft.com/en-us/library/system.diagnostics.trace(vs.71).aspx)

Debug Class
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemDiagnosticsDebugClassTopic.asp (http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfSystemDiagnosticsDebugClassTopic.asp)
Weitere Informationen zur Ablaufverfolgung finden Sie unter folgenden Themen in den Microsoft GotDotNet-Schnellstart-Lernprogrammen:
How Do I Work with tracing?
http://samples.gotdotnet.com/quickstart/howto/doc/Trace.aspx (http://samples.gotdotnet.com/quickstart/howto/doc/Trace.aspx)

How Do I Instrument a small application with tracing? http://samples.gotdotnet.com/quickstart/howto/doc/TraceDemo.aspx (http://samples.gotdotnet.com/quickstart/howto/doc/TraceDemo.aspx)

Die Informationen in diesem Artikel beziehen sich auf:
  • Microsoft Visual Basic .NET 2002 Standard Edition
Keywords: 
kbdebug kbhowto kbhowtomaster KB313417
Microsoft stellt Ihnen die in der Knowledge Base angebotenen Artikel und Informationen als Service-Leistung zur Verfügung. Microsoft übernimmt keinerlei Gewährleistung dafür, dass die angebotenen Artikel und Informationen auch in Ihrer Einsatzumgebung die erwünschten Ergebnisse erzielen. Die Entscheidung darüber, ob und in welcher Form Sie die angebotenen Artikel und Informationen nutzen, liegt daher allein bei Ihnen. Mit Ausnahme der gesetzlichen Haftung für Vorsatz ist jede Haftung von Microsoft im Zusammenhang mit Ihrer Nutzung dieser Artikel oder Informationen ausgeschlossen.
Freigeben
Weitere Supportoptionen
Microsoft Community-Supportforen
Kontaktieren Sie uns direkt
Zertifizierten Partner finden
Microsoft Store