Ablaufverfolgung und Debuggen in Visual C#

SPRACHE AUSWÄHLEN SPRACHE AUSWÄHLEN
Artikel-ID: 815788 - Produkte anzeigen, auf die sich dieser Artikel bezieht
Dieser Artikel ist eine Übersetzung des folgenden englischsprachigen Artikels der Microsoft Knowledge Base:
815788 How to trace and debug in Visual C#
Eine Version dieses Artikels für Microsoft Visual Basic .NET finden Sie unter 313417.
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.
Alles erweitern | Alles schließen

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

Die folgende Liste führt die empfohlene Hardware, Software und Netzwerkinfrastruktur sowie die benötigten Service Packs auf:
  • Microsoft Windows 2000, Microsoft Windows XP oder Microsoft Windows Server 2003
  • Microsoft Visual C# .NET oder Microsoft Visual C# 2005
Dieser Artikel setzt voraus, dass Sie mit dem Debuggen von Programmen vertraut sind.

Vorgehensweise


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 dabei helfen, die Programmausführungssequenz zu überwachen, Fehler zu erkennen oder Informationen zur Leistungsmessung zu 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 die folgenden 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 die folgenden:
  • 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 oder Visual Studio 2005.
  2. Erstellen Sie ein neues Visual C#-Konsolenanwendungsprojekt mit dem Namen conInfo. "Class1" wird in Visual Studio .NET erstellt. "Program.cs" wird in Visual Studio 2005 erstellt.
  3. Fügen Sie den folgenden Namespace oben in "Class1" oder "Program.cs" hinzu.
    using System.Diagnostics;
  4. Fügen Sie der Methode Main die folgenden Deklarationsanweisungen hinzu, um Variablen zu initialisieren, die Produktinformationen enthalten sollen:
    string sProdName = "Widget";
    int iUnitQty = 100;
    double dUnitCost = 1.03;
  5. 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 ");
  6. Verwenden Sie zur besseren Lesbarkeit die Methode Indent, um nachfolgende Meldungen im Ausgabefenster einzuziehen:
    Debug.Indent();
  7. 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.ToString());
    Debug.WriteLine("The per unit cost is " + dUnitCost.ToString());
  8. 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:
    System.Xml.XmlDocument oxml = new System.Xml.XmlDocument();
    Debug.WriteLine(oxml);
  9. Um die Ausgabe zu ordnen, 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.ToString(),"Field");
    Debug.WriteLine("Total Cost is  " + (iUnitQty * dUnitCost),"Calc");
  10. 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");
    
  11. 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 since dUnitcost < 1 is false");
    
  12. 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:
    TextWriterTraceListener tr1 = new TextWriterTraceListener(System.Console.Out);
    Debug.Listeners.Add(tr1);
            
    TextWriterTraceListener tr2 = new TextWriterTraceListener(System.IO.File.CreateText("Output.txt"));
    Debug.Listeners.Add(tr2);
  13. 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");
  14. Rufen Sie die Methode Flush für die Puffer der Klasse Debug auf, um zu gewährleisten, dass jedes Listener-Objekt seine vollständige Ausgabe 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 verwenden weitgehend die gleichen Methoden, um Ausgaben zu erzeugen. Zum Beispiel die folgenden:
  • 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();

Funktionsprüfung

  1. Stellen Sie sicher, dass Debug die aktuelle Projektmappenkonfiguration ist.
  2. Wenn das Fenster Projektmappen-Explorer nicht angezeigt wird, drücken Sie die Tastenkombination [STRG]+[ALT]+[L], um dieses Fenster einzublenden.
  3. Klicken Sie mit der rechten Maustaste auf conInfo. Klicken Sie dann auf Eigenschaften.
  4. Vergewissern Sie sich, dass der Pfeil im linken Fenster der conInfo-Eigenschaftenseite unter dem Ordner Konfiguration auf Debuggen zeigt.
  5. Klicken Sie über dem Ordner Konfiguration im Dropdown-Listenfeld Konfiguration auf Aktiv (Debuggen) oder auf Debuggen. Klicken Sie dann auf OK.
  6. Drücken Sie [STRG]+[ALT]+[O], um das Ausgabefenster anzuzeigen.
  7. Drücken Sie die Taste [F5], um den Code auszuführen. Wenn das Dialogfeld Assertionsfehler erscheint, klicken Sie auf Ignorieren.
  8. Drücken Sie im Konsolenfenster die [EINGABETASTE]. Jetzt sollte das Programm beendet werden, und im Ausgabefenster müsste die folgende Ausgabe erscheinen:
        Debug Information-Product Starting 
        The product name is Widget
        The available units on hand are100
        The per unit cost is 1.03
        System.Xml.XmlDocument
        Field: The product name is Widget
        Field: The units on hand are100
        Field: The per unit cost is1.03
        Calc: Total Cost is  103
        This message WILL appear
        ---- DEBUG ASSERTION FAILED ----
    ---- Assert Short Message ----
    Message will appear since dUnitcost  < 1 is false
    ---- Assert Long Message ----
    
    
        at Class1.Main(String[] args)  <%Path%>\class1.cs(34)
    
        The product name is Widget
        The available units on hand are100
        The per unit cost is 1.03
    Debug Information-Product Ending
    Trace Information-Product Starting 
        The product name is Widget
        Field: The product name isWidget
        This message WILL appear
    Trace Information-Product Ending
                        
    
  9. Das Konsolenfenster und die Datei "Output.txt" sollten die folgende Ausgabe anzeigen:
    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			
Hinweis: Diese Datei "Output.txt" wird im selben Ordner gespeichert wie die ausführbare conInfo-Datei (conInfo.exe). In der Regel handelt es sich dabei um den \bin-Ordner, in dem der Projektquellcode gespeichert wird. Standardmäßig ist dies der Ordner "C:\Dokumente und Einstellungen\User login\Eigene Dateien\Visual Studio Projects\conInfo\bin".

Vollständige Codeauflistung

   using System;
   using System.Diagnostics;

   class Class1
   {
      [STAThread]
      static void Main(string[] args)
      {
         string sProdName = "Widget";
         int iUnitQty = 100;
         double  dUnitCost = 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.ToString());
         Debug.WriteLine("The per unit cost is "+ dUnitCost.ToString());

         System.Xml.XmlDocument oxml = 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.ToString(),"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 since dUnitcost  < 1 is false");

         TextWriterTraceListener tr1 = new TextWriterTraceListener(System.Console.Out);
         Debug.Listeners.Add(tr1);
        
         TextWriterTraceListener tr2 = 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();
      }			   }
Hinweis: Damit dieser Beispielcode funktioniert, müssen Sie den Namespace System.Diagonstics hinzufügen, indem Sie using System.Diagnostics; als erste Zeile Ihres Codes einfügen.

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 Listeners-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.
             TextWriterTraceListener myWriter = new TextWriterTraceListener(System.Console.Out);
             Debug.Listeners.Add(myWriter);
            
             TextWriterTraceListener myCreator = new TextWriterTraceListener(System.Console.Out);
             Trace.Listeners.Add(myCreator);
             
    

Informationsquellen

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

Debug Class (Klasse "Debug")
http://msdn2.microsoft.com/en-us/library/system.diagnostics.debug(vs.71).aspx


Weitere Informationen zur Ablaufverfolgung finden Sie unter dem folgenden Thema in den Microsoft GotDotNet-Schnellstart-Lernprogrammen:
How Do I Work with tracing? (Wie verwende ich die Ablaufverfolgung?)
http://samples.gotdotnet.com/quickstart/howto/doc/Trace.aspx

Eigenschaften

Artikel-ID: 815788 - Geändert am: Montag, 25. Juni 2007 - Version: 2.6
Die Informationen in diesem Artikel beziehen sich auf:
  • Microsoft Visual C# .NET 2002 Standard Edition
  • Microsoft Visual C# .NET 2003 Standard Edition
  • Microsoft Visual C# 2005 Express Edition
Keywords: 
kbprogramming kbdebug kbnamespace kbhowtomaster KB815788
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.

Ihr Feedback an uns

 

Contact us for more help

Contact us for more help
Connect with Answer Desk for expert help.
Get more support from smallbusiness.support.microsoft.com