Ablaufverfolgung und Debuggen in Visual C sharp
In diesem Artikel wird beschrieben, wie Sie die Ablaufverfolgung und das Debuggen in Visual C# durchführen, und es werden einige Beispielschritte zur Erläuterung verwandter Informationen bereitgestellt.
Ursprüngliche Produktversion: Visual C#
Ursprüngliche KB-Nummer: 815788
Zusammenfassung
Eine Microsoft Visual Basic .NET-Version dieses Artikels finden Sie unter Verwenden von Ablaufverfolgungs- und Debugklassen in Visual Basic .NET.
Dieser Artikel bezieht sich auf das .NET Framework Namespacesystem der Klassenbibliothek. Diagnose und beschreibt die Verwendung der Debug
-Klasse und der Trace
-Klasse. Diese Klassen sind im .NET Framework verfügbar. Sie können diese Klassen verwenden, um Informationen zur Leistung einer Anwendung bereitzustellen, entweder während der Anwendungsentwicklung oder nach der Bereitstellung in der Produktion. 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:
- Microsoft Windows
- Microsoft Visual C#
In diesem Artikel wird auch davon ausgegangen, dass Sie mit dem Debuggen von Programmen 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 Meldungen zu erzeugen, die Ihnen helfen, die Ausführungssequenz des Programms zu überwachen, Fehlfunktionen zu erkennen oder Informationen zur Leistungsmessung bereitzustellen. Standardmäßig werden die von der Debug
-Klasse erzeugten Meldungen im Fenster Ausgabe der integrierten Entwicklungsumgebung (Integrated Development Environment, IDE) von Visual Studio 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, zeigt das Ausgabefenster nur dann eine Meldung an, wenn eine angegebene Bedingung als false ausgewertet wird. Die Meldung wird dem Benutzer auch in einem modalem Dialogfeld angezeigt. Das Dialogfeld enthält die Meldung, den Projektnamen und den Debug
. Assert-Anweisungsnummer. Das Dialogfeld enthält auch die folgenden drei Befehlsschaltflächen:
Abbrechen: Die Anwendung wird nicht mehr ausgeführt.
Wiederholen: Die Anwendung wechselt in den Debugmodus.
Ignorieren: Die Anwendung wird fortgesetzt. Der Benutzer muss auf eine dieser Schaltflächen klicken, bevor die Anwendung fortgesetzt werden kann.
Sie können die Ausgabe der Debug
-Klasse auch an andere Ziele als das Ausgabefenster weiterleiten. Die Debug
-Klasse verfügt über eine Listeners-Auflistung, die -Objekte enthält Listener
.
Jedes Listenerobjekt überwacht Debug
die Ausgabe und leitet die Ausgabe an ein angegebenes Ziel weiter.
Jeder Listener in der Listenerauflistung empfängt jede Ausgabe, die die Debug
Klasse generiert. Verwenden Sie die TextWriterTraceListener
-Klasse, um -Objekte zu definieren Listener
. Sie können das Ziel für eine TextWriterTraceListener
Klasse über ihren Konstruktor angeben.
Folgende Ausgabeziele sind möglich:
- Das Konsolenfenster mithilfe der
System.Console.Out
-Eigenschaft. - Eine Textdatei (.txt mithilfe der
System.IO.File.CreateText("FileName.txt")
-Anweisung). Nachdem Sie einTextWriterTraceListener
-Objekt erstellt haben, müssen Sie das -Objekt demDebug
hinzufügen. Listenersammlung zum EmpfangenDebug
der Ausgabe.
Erstellen eines Beispiels mit der Debugklasse
Starten Sie Visual Studio oder Visual C# Express Edition.
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.
Fügen Sie den folgenden Namespace oben in Class1 oder Program.cs hinzu.
using System.Diagnostics;
Um Variablen so zu initialisieren, dass sie Informationen zu einem Produkt enthalten, fügen Sie die folgenden Deklarationsanweisungen zur Main-Methode hinzu:
string sProdName = "Widget"; int iUnitQty = 100; double dUnitCost = 1.03;
Geben Sie die Meldung an, die die Klasse als ersten Eingabeparameter der
WriteLine
-Methode erzeugt. Drücken Sie die Tastenkombination STRG+ALT+O , um sicherzustellen, dass das Fenster Ausgabe angezeigt wird.Debug.WriteLine("Debug Information-Product Starting ");
Verwenden Sie aus Gründen der Lesbarkeit die
Indent
-Methode, um nachfolgende Meldungen im Ausgabefenster einzurücken:Debug.Indent();
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.ToString()); Debug.WriteLine("The per unit cost is " + dUnitCost.ToString());
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. denSystem.Xml.XmlDocument
Namespace im Ausgabefenster an:System.Xml.XmlDocument oxml = new System.Xml.XmlDocument(); Debug.WriteLine(oxml);
Um die Ausgabe zu organisieren, können Sie eine Kategorie als optionalen, zweiten Eingabeparameter der
WriteLine
Methode einschließen. Wenn Sie eine Kategorie angeben, lautet das Format der Ausgabefenstermeldung "Category: message". In der ersten Zeile des folgenden Codes wird beispielsweise "Field: The product name is Widget" (Feld: Der Produktname ist Widget) im Ausgabefenster 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.ToString(),"Field"); Debug.WriteLine("Total Cost is " + (iUnitQty * dUnitCost),"Calc");
Im Ausgabefenster können Meldungen nur angezeigt werden, wenn eine angegebene Bedingung mithilfe der
WriteLineIf
-Methode derDebug
-Klasse als true ausgewertet wird. Die auszuwertende Bedingung ist der erste Eingabeparameter derWriteLineIf
Methode. Der zweite Parameter vonWriteLineIf
ist die Meldung, die nur angezeigt wird, wenn die Bedingung im ersten Parameter als true ausgewertet wird.Debug.WriteLineIf(iUnitQty > 50, "This message WILL appear"); Debug.WriteLineIf(iUnitQty < 50, "This message will NOT appear");
Verwenden Sie die Assert-Methode der
Debug
-Klasse, damit im Ausgabefenster die Meldung 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 since dUnitcost < 1 is false");
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 Debuglisteners-Auflistung 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);
Verwenden Sie aus Gründen der Lesbarkeit die
Unindent
-Methode, um den Einzug für nachfolgende Nachrichten zu entfernen, die von derDebug
Klasse generiert werden. Wenn Sie dieIndent
-Methode und dieUnindent
-Methode zusammen verwenden, kann der Reader die Ausgabe als Gruppe unterscheiden.Debug.Unindent(); Debug.WriteLine("Debug Information-Product Ending");
Um sicherzustellen, dass jedes
Listener
Objekt seine gesamte Ausgabe empfängt, rufen Sie die Flush-Methode für dieDebug
Klassenpuffer auf:Debug.Flush();
Verwenden der Ablaufverfolgungsklasse
Sie können die Trace
-Klasse auch verwenden, um Nachrichten zu erzeugen, die die Ausführung einer Anwendung überwachen. Die Trace
Klassen und Debug
verwenden die meisten der gleichen Methoden, um eine Ausgabe zu erzeugen, einschließlich der folgenden:
- WriteLine
- Writelineif
- Einzug
- Unindent
- Assert
- Flush
Sie können die Trace
Klassen und separat Debug
oder zusammen in derselben Anwendung verwenden. In einem Debugprojekt für die Projektmappenkonfiguration sind sowohl als Debug
auch Trace
die Ausgabe aktiv. Das Projekt generiert die Ausgabe beider Klassen für alle Listener
Objekte. Ein Projekt für die Releaselösungskonfiguration generiert jedoch nur eine Ausgabe aus einer Trace
Klasse. Das Projekt Release Solution Configuration ignoriert alle Debug
Aufrufe von Klassenmethoden.
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
Stellen Sie sicher, dass Debuggen die aktuelle Projektmappenkonfiguration ist.
Wenn das Projektmappen-Explorer Fensters nicht sichtbar ist, drücken Sie die Tastenkombination STRG+ALT+L, um dieses Fenster anzuzeigen.
Klicken Sie mit der rechten Maustaste auf conInfo, und klicken Sie dann auf Eigenschaften.
Stellen Sie im linken Bereich der conInfo-Eigenschaftenseite unter dem Ordner Konfiguration sicher, dass der Pfeil auf Debuggen zeigt.
Hinweis
Klicken Sie in Visual C# 2005 und Visual C# 2005 Express Edition auf der seite conInfo auf Debuggen.
Klicken Sie über dem Ordner Konfiguration im Dropdown-Listenfeld Konfiguration auf Aktiv (Debuggen) oder Debuggen, und klicken Sie dann auf OK. Klicken Sie in Visual C# 2005 und Visual C# 2005 Express Edition im Dropdown-Listenfeld Konfiguration auf der Seite Debuggen auf Aktiv (Debuggen) oder Debuggen, und klicken Sie dann im Menü Datei auf Speichern.
Drücken Sie STRG+ALT+O , um das Ausgabefenster anzuzeigen.
Drücken Sie F5 , um den Code auszuführen. Wenn das Dialogfeld Assertionsfehler angezeigt wird, klicken Sie auf Ignorieren.
Drücken Sie im Konsolenfenster die EINGABETASTE. Das Programm sollte abgeschlossen werden, und im Ausgabefenster sollte die Ausgabe angezeigt werden, die der folgenden ähnelt:
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
Im Konsolenfenster und in der dateiOutput.txt sollte die folgende Ausgabe angezeigt werden:
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
Die Output.txt-Datei befindet sich im selben Verzeichnis wie die ausführbare conInfo-Datei (conInfo.exe). In der Regel ist dies der Ordner \bin, in dem die Projektquelle gespeichert ist. Der Standardwert ist C:\Documents and Settings\User login\My Documents\Visual Studio Projects\conInfo\bin
. In Visual C# 2005 und Visual C# 2005 Express Edition befindet sich die dateiOutput.txt im Ordner . C:\Documents and Settings\User login\My Documents\Visual Studio 2005\Projects\conInfo\conInfo\bin\Debug
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();
}
}
Troubleshooting
Wenn der Konfigurationstyp der Lösung Release ist, wird die
Debug
Klassenausgabe ignoriert.Nachdem Sie eine
TextWriterTraceListener
Klasse für ein bestimmtes Ziel erstellt haben,TextWriterTraceListener
empfängt die Ausgabe derTrace
-Klasse und derDebug
-Klasse. Dies geschieht unabhängig davon, ob Sie dieAdd
-Methode vonTrace
oder dieDebug
-Klasse verwenden, um derListeners
-Klasse hinzuzufügenTextWriterTraceListener
.Wenn Sie ein
Listeners
Objekt für dasselbe Ziel in undTrace
denDebug
Klassen hinzufügen, wird jede Ausgabezeile dupliziert, unabhängig davon, obDebug
oderTrace
die Ausgabe generiert wird.TextWriterTraceListener myWriter = new TextWriterTraceListener(System.Console.Out); Debug.Listeners.Add(myWriter); TextWriterTraceListener myCreator = new TextWriterTraceListener(System.Console.Out); Trace.Listeners.Add(myCreator);
References
Feedback
https://aka.ms/ContentUserFeedback.
Bald verfügbar: Im Laufe des Jahres 2024 werden wir GitHub-Issues stufenweise als Feedbackmechanismus für Inhalte abbauen und durch ein neues Feedbacksystem ersetzen. Weitere Informationen finden Sie unterFeedback senden und anzeigen für