Ablaufverfolgung und Debug in Visual C sharp

2024-12-14

In diesem Artikel wird beschrieben, wie Sie die Ablaufverfolgung und das Debuggen in Visual C# durchführen und einige Beispielschritte zur Erläuterung verwandter Informationen bereitstellen.

Originalproduktversion: 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 Class Library Namespace System. Diagnose und Beschreibung der Verwendung der Debug Klassen und der Trace Klassen. Diese Klassen sind im .NET Framework verfügbar. Mithilfe dieser Klassen können Sie Informationen zur Leistung einer Anwendung während der Anwendungsentwicklung oder nach der Bereitstellung in der Produktion bereitstellen. Diese Klassen sind nur ein Teil der Instrumentierungsfeatures, die in .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 Programmdebugging vertraut sind.

Beschreibung der Technik

Die Schritte im Abschnitt "Beispiel erstellen 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 Ihnen helfen, die Programmausführungssequenz zu überwachen, Fehlfunktionen zu erkennen oder Leistungsmessungsinformationen bereitzustellen. Standardmäßig werden die von der Debug Klasse erzeugten Nachrichten im Ausgabefenster 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 Zeilenterminator 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 eine Meldung nur an, wenn eine angegebene Bedingung als falsch ausgewertet wird. Die Meldung wird auch in einem modalen Dialogfeld für den Benutzer angezeigt. Das Dialogfeld enthält die Meldung, den Projektnamen und die Debug. Assert-Anweisungsnummer. Das Dialogfeld enthält auch die folgenden drei Befehlsschaltflächen:

Abbrechen: Die Anwendung wird beendet.
Wiederholen: Die Anwendung wechselt in den Debugmodus.
Ignorieren: Die Anwendung wird fortgesetzt. Der Benutzer muss auf eine dieser Schaltflächen klicken, bevor die Anwendung fortfahren kann.

Sie können die Ausgabe auch von der Debug Klasse an andere Ziele als das Ausgabefenster weiterleiten. Die Debug Klasse verfügt über eine Listeners-Auflistung, die Objekte enthält Listener .

Jedes Listener-Objekt überwacht Debug die Ausgabe und leitet die Ausgabe an ein angegebenes Ziel weiter.

Jeder Listener in der Listener-Auflistung 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 den Konstruktor angeben.

Einige mögliche Ausgabeziele umfassen Folgendes:

Das Konsolenfenster mithilfe der System.Console.Out Eigenschaft.
Eine Textdatei (.txt) mithilfe der System.IO.File.CreateText("FileName.txt") Anweisung. Nachdem Sie ein TextWriterTraceListener Objekt erstellt haben, müssen Sie das Objekt dem Debug. Listeners-Auflistung zum Empfangen der Debug 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. Klasse1 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 zu initialisieren, die Informationen zu einem Produkt enthalten sollen, fügen Sie der Main-Methode die folgenden Deklarationsanweisungen hinzu:
```
string sProdName = "Widget";
int iUnitQty = 100;
double dUnitCost = 1.03;
```
Geben Sie die Nachricht an, die die Klasse als ersten Eingabeparameter der WriteLine Methode erzeugt. Drücken Sie die TASTENkombination STRG+ALT+O , um sicherzustellen, dass das Ausgabefenster sichtbar ist.
```
Debug.WriteLine("Debug Information-Product Starting ");
```
Verwenden Sie zur 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 beispielsweise den System.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 Meldung des Ausgabefensters "Kategorie: Nachricht". Die erste Zeile des folgenden Codes zeigt z. B. "Feld: Der Produktname ist 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");
```
Das Ausgabefenster kann Meldungen nur anzeigen, wenn eine festgelegte Bedingung mithilfe WriteLineIf der Methode der Debug Klasse auf "true" ausgewertet wird. Die zu bewertende 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");
```
Verwenden Sie die Assert-Methode der Debug Klasse, sodass 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 zur Lesbarkeit die Unindent Methode, um den Einzug für nachfolgende Nachrichten zu entfernen, die von der Debug Klasse generiert werden. Wenn Sie die Indent Und die Unindent Methoden zusammen verwenden, kann der Leser die Ausgabe als Gruppe unterscheiden.
```
Debug.Unindent();
Debug.WriteLine("Debug Information-Product Ending");
```
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 Ablaufverfolgungsklasse

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

WriteLine
WriteLineIf
Einrücken
Unindent
Assert
Leerung

Sie können die Trace Klassen und Die Debug Klassen separat oder in derselben Anwendung verwenden. In einem Debuglösungskonfigurationsprojekt sind beide Trace und Debug die Ausgabe aktiv. Das Projekt generiert ausgabe aus beiden Klassen für alle Listener Objekte. Ein Projekt für die Versionslösungskonfiguration generiert jedoch nur Ausgaben aus einer Trace Klasse. Das Projekt für die Versionslösungskonfiguration 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 sie funktioniert

Stellen Sie sicher, dass "Debuggen" die aktuelle Lösungskonfiguration ist.
Wenn das Projektmappen-Explorer Fenster 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 Konfigurationsordner sicher, dass der Pfeil auf "Debuggen" zeigt.

Notiz

Klicken Sie in Visual C# 2005 und in Visual C# 2005 Express Edition auf "Debuggen " auf der ConInfo-Seite .
Klicken Sie oberhalb des Konfigurationsordners im Dropdown-Listenfeld "Konfiguration" auf "Aktiv " (Debuggen) oder "Debuggen", und klicken Sie dann auf "OK". Klicken Sie in Visual C# 2005 und in Visual C# 2005 Express Edition im Dropdown-Listenfeld "Konfiguration" auf "Aktiv ( Debuggen) oder Debuggen" auf der Seite "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 "Assertion fehlgeschlagen " angezeigt wird, klicken Sie auf "Ignorieren".

Drücken Sie im Konsolenfenster die EINGABETASTE. Das Programm sollte abgeschlossen sein, und das Ausgabefenster sollte die Ausgabe anzeigen, die wie folgt aussieht:

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

Das Konsolenfenster und die datei Output.txt sollte 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

Notiz

Die Output.txt Datei befindet sich im selben Verzeichnis wie die ausführbare Datei conInfo (conInfo.exe). In der Regel ist dies der Ordner "\bin", in dem die Projektquelle gespeichert ist. Standardmäßig ist dies C:\Documents and Settings\User login\My Documents\Visual Studio Projects\conInfo\bin. In Visual C# 2005 und in Visual C# 2005 Express Edition befindet sich die datei Output.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();
    }
}

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 wird die Ausgabe der Trace Klassen und der Debug Klassen empfangen. 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 in den Klassen ein Listeners Objekt für dasselbe Ziel hinzufügen, wird jede Ausgabezeile dupliziert, unabhängig davon, ob Debug die Ausgabe generiert oder Trace generiert Debug wird.Trace

TextWriterTraceListener myWriter = new TextWriterTraceListener(System.Console.Out);
Debug.Listeners.Add(myWriter);

TextWriterTraceListener myCreator = new TextWriterTraceListener(System.Console.Out);
Trace.Listeners.Add(myCreator);

Freigeben über