Usare le classi Trace e Debug in Visual Basic .NET

Articolo
07/17/2023

Questo articolo fornisce informazioni su come usare le Debug classi e Trace in Visual Basic .NET.

Versione originale del prodotto: Visual Basic .NET
Numero KB originale: 313417

Riepilogo

Questo articolo illustra come usare le Debug classi e Trace . Queste classi sono disponibili in Microsoft .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:

Windows
Visual Basic .NET

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, 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 Microsoft 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.

Se 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 il numero di Debug.Assert istruzione. La finestra di dialogo include anche tre pulsanti di comando:

Interruzione: l'applicazione smette di essere eseguita.
Riprova: l'applicazione entra in modalità di debug.
Ignora: 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 ha una raccolta denominata Listeners che include oggetti Listener. Ogni oggetto Listener monitora Debug l'output e indirizza l'output a una destinazione specificata. Ogni listener nella Listeners raccolta riceve qualsiasi output generato dalla Debug classe . Utilizzare la TextWriterTraceListener classe per definire gli oggetti Listener. È possibile specificare la destinazione per una TextWriterTraceListener classe tramite il relativo costruttore. Alcune possibili destinazioni di output includono:

La finestra Console utilizzando la System.Console.Out proprietà .
File di testo tramite l'istruzione System.IO.File.CreateText("FileName.txt")) .

Dopo aver creato un TextWriterTraceListener oggetto, è necessario aggiungere l'oggetto alla raccolta per ricevere Debug l'outputDebug.Listeners.

Creare un esempio con la classe Debug

Usare Visual Basic .NET per creare un nuovo progetto applicazione console denominato conInfo. Un modulo pubblico denominato Module1 viene aggiunto al progetto per impostazione predefinita.
Per inizializzare le variabili per contenere informazioni su un prodotto, aggiungere le istruzioni seguenti Dim :
```
Dim sProdName As String = "Widget"
Dim iUnitQty As Integer = 100
Dim dUnitCost As Decimal = 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)
Debug.WriteLine("The per unit cost is " & dUnitCost)

È 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:
```
Dim oxml As 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, "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")
```

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

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)

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 oggetto Listener riceva tutto il relativo output, chiamare il Flush metodo 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 output, tra cui:

WriteLine
WriteLineIf
Indent
Unindent
Assert
Flush

È 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 oggetti Listener. 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.
Nella casella di riepilogo a discesa Configurazione sopra la cartella Configuration fare clic su Active (Debug) o Debug e quindi fare clic su OK.
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 nella finestra Output dovrebbe essere visualizzato l'output seguente:

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

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

(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

Elenco di codice completo

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 TextWriter`Trace`Listener(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

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 oggetto Listener 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.
```
Dim tr1 As New TextWriterTraceListener(System.Console.Out)
Debug.Listeners.Add(tr1)
Dim tr2 As New TextWriterTraceListener(System.Console.Out)
Trace.Listeners.Add(tr2)
```