Traccia e debug in Visual C sharp

Articolo
07/17/2023

Questo articolo descrive come tracciare ed eseguire il debug in Visual C# e fornisce alcuni passaggi di esempio per spiegare le informazioni correlate.

Versione originale del prodotto: Oggetto visivo C#
Numero KB originale: 815788

Riepilogo

Per una versione di Microsoft Visual Basic .NET di questo articolo, vedere Usare le classi di traccia e debug in Visual Basic .NET.

Questo articolo fa riferimento allo spazio dei nomi della libreria di classi .NET Framework System. Diagnostica e descrive come usare le Debug classi e Trace . Queste classi sono disponibili in .NET Framework. È possibile usare queste classi per fornire informazioni sulle prestazioni di un'applicazione durante lo sviluppo di applicazioni o dopo la distribuzione nell'ambiente di produzione. Queste classi sono solo una parte delle funzionalità di strumentazione disponibili in .NET Framework.

Requisiti

L'elenco seguente descrive l'hardware, il software, l'infrastruttura di rete e i Service Pack consigliati necessari:

Microsoft Windows
Microsoft Visual C#

Questo articolo presuppone anche che si abbia familiarità con il debug del programma.

Descrizione della tecnica

I passaggi della sezione Creare un esempio con la classe debug illustrano come creare un'applicazione console che usa la Debug classe per fornire informazioni sull'esecuzione del programma.

Quando il programma viene eseguito, è possibile usare i metodi della Debug classe per produrre messaggi che consentono di monitorare la sequenza di esecuzione del programma, rilevare malfunzionamenti o fornire informazioni sulla misurazione delle prestazioni. Per impostazione predefinita, i messaggi generati dalla Debug classe vengono visualizzati nella finestra Output dell'ambiente di sviluppo integrato (IDE) di Visual Studio.

Il codice di esempio usa il WriteLine metodo per produrre un messaggio seguito da un terminatore di riga. Quando si usa questo metodo per generare un messaggio, ogni messaggio viene visualizzato in una riga separata nella finestra Output.

Quando si usa il Assert metodo della Debug classe , nella finestra Output viene visualizzato un messaggio solo se una condizione specificata restituisce false. Il messaggio viene visualizzato anche in una finestra di dialogo modale per l'utente. La finestra di dialogo include il messaggio, il nome del progetto e .Debug Asserzione del numero di istruzione. La finestra di dialogo include anche i tre pulsanti di comando seguenti:

Interrompere: L'applicazione smette di essere eseguita.
Riprova: L'applicazione entra in modalità di debug.
Ignorare: L'applicazione procede. L'utente deve fare clic su uno di questi pulsanti prima che l'applicazione possa continuare.

È anche possibile indirizzare l'output dalla Debug classe a destinazioni diverse dalla finestra Output. La Debug classe dispone di un insieme Listeners che include Listener oggetti .

Ogni oggetto Listener monitora Debug l'output e indirizza l'output a una destinazione specificata.

Ogni listener nell'insieme Listener riceve qualsiasi output generato dalla Debug classe . Utilizzare la TextWriterTraceListener classe per definire Listener gli oggetti . È possibile specificare la destinazione per una TextWriterTraceListener classe tramite il relativo costruttore.

Alcune possibili destinazioni di output includono quanto segue:

La finestra Console utilizzando la System.Console.Out proprietà .
Un file di testo (.txt) usando l'istruzione System.IO.File.CreateText("FileName.txt") . Dopo aver creato un TextWriterTraceListener oggetto , è necessario aggiungere l'oggetto a Debug. Raccolta di listener per ricevere Debug l'output.

Creare un esempio con la classe Debug

Avviare Visual Studio o Visual C# Express Edition.
Creare un nuovo progetto applicazione console Visual C# denominato conInfo. Class1 viene creato in Visual Studio .NET. Program.cs viene creato in Visual Studio 2005.
Aggiungere lo spazio dei nomi seguente all'inizio in Class1 o Program.cs.
```
using System.Diagnostics;
```
Per inizializzare le variabili per contenere informazioni su un prodotto, aggiungere le istruzioni di dichiarazione seguenti al metodo Main:
```
string sProdName = "Widget";
int iUnitQty = 100;
double dUnitCost = 1.03;
```
Specificare il messaggio prodotto dalla classe come primo parametro di input del WriteLine metodo . Premere la combinazione di tasti CTRL+ALT+O per assicurarsi che la finestra Output sia visibile.
```
Debug.WriteLine("Debug Information-Product Starting ");
```
Per la leggibilità, usare il metodo per impostare il Indent rientro dei messaggi successivi nella finestra Output:
```
Debug.Indent();
```

Per visualizzare il contenuto delle variabili selezionate, usare il WriteLine metodo come indicato di seguito:

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

È anche possibile utilizzare il WriteLine metodo per visualizzare lo spazio dei nomi e il nome della classe per un oggetto esistente. Ad esempio, il codice seguente visualizza lo System.Xml.XmlDocument spazio dei nomi nella finestra Output:
```
System.Xml.XmlDocument oxml = new System.Xml.XmlDocument();
Debug.WriteLine(oxml);
```
Per organizzare l'output, è possibile includere una categoria come secondo parametro di input facoltativo del WriteLine metodo. Se si specifica una categoria, il formato del messaggio della finestra Output è "category: message". Ad esempio, nella prima riga del codice seguente viene visualizzato "Campo: Il nome del prodotto è Widget" nella finestra Output:
```
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");
```
La finestra Output può visualizzare i messaggi solo se una condizione designata restituisce true usando il WriteLineIf metodo della Debug classe . La condizione da valutare è il primo parametro di input del WriteLineIf metodo. Il secondo parametro di WriteLineIf è il messaggio visualizzato solo se la condizione nel primo parametro restituisce true.
```
Debug.WriteLineIf(iUnitQty > 50, "This message WILL appear");
Debug.WriteLineIf(iUnitQty < 50, "This message will NOT appear");
```
Utilizzare il metodo Assert della Debug classe in modo che nella finestra Output venga visualizzato il messaggio solo se una condizione specificata restituisce false:
```
Debug.Assert(dUnitCost > 1, "Message will NOT appear");
Debug.Assert(dUnitCost < 1, "Message will appear since dUnitcost < 1 is false");
```

Creare gli TextWriterTraceListener oggetti per la finestra Console (tr1) e per un file di testo denominato Output.txt (tr2) e quindi aggiungere ogni oggetto all'insieme Listener di debug:

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

Per la leggibilità, utilizzare il Unindent metodo per rimuovere il rientro per i messaggi successivi generati dalla Debug classe . Quando si usano insieme i Indent metodi e Unindent , il lettore può distinguere l'output come gruppo.
```
Debug.Unindent();
Debug.WriteLine("Debug Information-Product Ending");
```
Per assicurarsi che ogni Listener oggetto riceva tutto il relativo output, chiamare il metodo Flush per i buffer di Debug classe:
```
Debug.Flush();
```

Uso della classe Trace

È anche possibile usare la Trace classe per produrre messaggi che monitorano l'esecuzione di un'applicazione. Le Trace classi e Debug condividono la maggior parte degli stessi metodi per produrre l'output, inclusi i seguenti:

Writeline
Writelineif
Trattino
Unindent
Affermare
Sciacquone

È possibile usare le Trace classi e Debug separatamente o insieme nella stessa applicazione. In un progetto di configurazione della soluzione di debug, sia che TraceDebug l'output siano attivi. Il progetto genera l'output da entrambe queste classi a tutti gli Listener oggetti . Tuttavia, un progetto di configurazione della soluzione di rilascio genera solo l'output da una Trace classe . Il progetto Release Solution Configuration ignora tutte Debug le chiamate al metodo di classe.

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

Verificare che funzioni

Assicurarsi che Debug sia la configurazione della soluzione corrente.
Se la finestra Esplora soluzioni non è visibile, premere la combinazione di tasti CTRL+ALT+L per visualizzare questa finestra.
Fare clic con il pulsante destro del mouse su conInfo e quindi scegliere Proprietà.
Nel riquadro sinistro della pagina delle proprietà conInfo , nella cartella Configurazione , assicurarsi che la freccia punti a Debug.

Nota

In Visual C# 2005 e in Visual C# 2005 Express Edition fare clic su Debug nella pagina conInfo .
Nella casella di riepilogo a discesa Configurazione sopra la cartella Configuration fare clic su Active (Debug) o Debug e quindi fare clic su OK. In Visual C# 2005 e in Visual C# 2005 Express Edition fare clic su Active (Debug) o Debug nella casella di riepilogo a discesa Configurazione nella pagina Debug e quindi scegliere Salva dal menu File .
Premere CTRL+ALT+O per visualizzare la finestra Output .
Premere F5 per eseguire il codice. Quando viene visualizzata la finestra di dialogo Asserzione non riuscita , fare clic su Ignora.

Nella finestra Console premere INVIO. Il programma dovrebbe terminare e la finestra Output dovrebbe visualizzare l'output simile al seguente:

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

La finestra Console e il file Output.txt devono visualizzare l'output seguente:

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

Nota

Il file Output.txt si trova nella stessa directory del file eseguibile conInfo (conInfo.exe). In genere, si tratta della cartella \bin in cui è archiviata l'origine del progetto. Per impostazione predefinita, si tratta di C:\Documents and Settings\User login\My Documents\Visual Studio Projects\conInfo\bin. In Visual C# 2005 e in Visual C# 2005 Express Edition il file Output.txt si trova nella cartella : C:\Documents and Settings\User login\My Documents\Visual Studio 2005\Projects\conInfo\conInfo\bin\Debug.

Elenco di codice completo

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

Risoluzione dei problemi

Se il tipo di configurazione della soluzione è Release, l'output della Debug classe viene ignorato.
Dopo aver creato una TextWriterTraceListener classe per una destinazione specifica, TextWriterTraceListener riceve l'output Trace dalle classi e Debug . Ciò si verifica indipendentemente dal fatto che si usi il Add metodo dell'oggetto Trace o della Debug classe per aggiungere TextWriterTraceListener alla Listeners classe .

Se si aggiunge un Listeners oggetto per la stessa destinazione nelle Trace classi e Debug , ogni riga di output viene duplicata, indipendentemente dal fatto che l'output venga generato o Trace menoDebug.

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

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