Tracerings- en foutopsporingsklassen gebruiken in Visual Basic .NET

Dit artikel bevat informatie over het gebruik van en Debug de Trace klassen in Visual Basic .NET.

Oorspronkelijke productversie: Visual Basic .NET
Oorspronkelijk KB-nummer: 313417

Samenvatting

In dit artikel wordt gedemonstreert hoe u de Debug en de Trace klassen gebruikt. Deze klassen zijn beschikbaar in Microsoft .NET Framework. U kunt deze klassen gebruiken om informatie te geven over de prestaties van een toepassing tijdens het ontwikkelen van toepassingen of na de implementatie naar productie. Deze klassen zijn slechts één onderdeel van de instrumentatiefuncties die beschikbaar zijn in .NET Framework.

Behoeften

De volgende lijst bevat een overzicht van de aanbevolen hardware, software, netwerkinfrastructuur en servicepacks die u nodig hebt:

Windows
Visual Basic .NET

In dit artikel wordt ook ervan uitgegaan dat u bekend bent met het opsporen van programmafouten.

Beschrijving van de techniek

De stappen in het gedeelte Een voorbeeld maken met de sectie Foutopsporingsklasse laten zien hoe u een consoletoepassing maakt die gebruikmaakt van de Debug klasse om informatie te verstrekken over de uitvoering van het programma.

Wanneer het programma wordt uitgevoerd, kunt u methoden van de Debug klasse gebruiken om berichten te produceren die helpen bij het bewaken, detecteren van storingen of om prestatiemetingsinformatie te verstrekken. De berichten die de Debug klasse produceert, worden standaard weergegeven in het uitvoervenster van de Microsoft Visual Studio Integrated Development Environment (IDE).

De voorbeeldcode gebruikt de WriteLine methode om een bericht te produceren dat wordt gevolgd door een regeleindteken. Wanneer u deze methode gebruikt om een bericht te produceren, wordt elk bericht weergegeven op een afzonderlijke regel in het venster Uitvoer.

Als u de Assert methode van de Debug klasse gebruikt, wordt in het uitvoervenster alleen een bericht weergegeven als een opgegeven voorwaarde resulteert in onwaar. Het bericht wordt ook weergegeven in een modaal dialoogvenster voor de gebruiker. Het dialoogvenster bevat het bericht, de projectnaam en het Debug.Assert instructienummer. Het dialoogvenster bevat ook drie opdrachtknoppen:

Afgebroken: de toepassing wordt niet meer uitgevoerd.
Opnieuw proberen: De toepassing voert de foutopsporingsmodus in.
Negeren: de toepassing gaat verder. De gebruiker moet op een van deze knoppen klikken voordat de toepassing kan doorgaan.

U kunt ook uitvoer van de Debug klasse naar andere bestemmingen dan het uitvoervenster leiden. De Debug klasse heeft een verzameling met de naam Listeners Listener-objecten. Elk listener-object bewaakt Debug de uitvoer en stuurt de uitvoer door naar een opgegeven doel. Elke listener in de Listeners verzameling ontvangt uitvoer die door de Debug klasse wordt gegenereerd. Gebruik de TextWriterTraceListener klasse om listenerobjecten te definiëren. U kunt het doel voor een TextWriterTraceListener klasse opgeven via de constructor. Enkele mogelijke uitvoerdoelen zijn:

Het consolevenster met behulp van de System.Console.Out eigenschap.
Een tekstbestand met behulp van de System.IO.File.CreateText("FileName.txt")) instructie.

Nadat u een TextWriterTraceListener object hebt gemaakt, moet u het object toevoegen aan de Debug.Listeners verzameling om uitvoer te ontvangen Debug .

Een voorbeeld maken met de foutopsporingsklasse

Gebruik Visual Basic .NET om een nieuw consoletoepassingsproject met de naam conInfo te maken. Een openbare module met de naam Module1 wordt standaard toegevoegd aan het project.
Als u variabelen wilt initialiseren om informatie over een product te bevatten, voegt u de volgende Dim instructies toe:
```
Dim sProdName As String = "Widget"
Dim iUnitQty As Integer = 100
Dim dUnitCost As Decimal = 1.03
```
Geef het bericht op dat de klasse produceert als de eerste invoerparameter van de WriteLine methode. Druk op de toetsencombinatie Ctrl+Alt+O om ervoor te zorgen dat het uitvoervenster zichtbaar is.
```
Debug.WriteLine("Debug Information-Product Starting ")
```
Gebruik voor leesbaarheid de Indent methode om volgende berichten in te latenspringen in het venster Uitvoer:
```
Debug.Indent()
```

Als u de inhoud van geselecteerde variabelen wilt weergeven, gebruikt u de WriteLine methode als volgt:

Debug.WriteLine("The product name is " & sProdName)
Debug.WriteLine("The available units on hand are " & iUnitQty)
Debug.WriteLine("The per unit cost is " & dUnitCost)

U kunt ook de WriteLine methode gebruiken om de naamruimte en de klassenaam voor een bestaand object weer te geven. Met de volgende code wordt bijvoorbeeld de System.Xml.XmlDocument naamruimte weergegeven in het uitvoervenster:
```
Dim oxml As New System.Xml.XmlDocument()
Debug.WriteLine(oxml)
```
Als u de uitvoer wilt ordenen, kunt u een categorie opnemen als een optionele tweede invoerparameter van de WriteLine methode. Als u een categorie opgeeft, is de indeling van het bericht Uitvoervenster 'categorie: bericht'. Op de eerste regel van de volgende code wordt bijvoorbeeld 'Veld: De productnaam is Widget' weergegeven in het uitvoervenster:
```
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")
```
In het uitvoervenster kunnen alleen berichten worden weergegeven als een aangewezen voorwaarde resulteert in waar met behulp van de WriteLineIf methode van de Debug klasse. De voorwaarde die moet worden geëvalueerd, is de eerste invoerparameter van de WriteLineIf methode. De tweede parameter is WriteLineIf het bericht dat alleen wordt weergegeven als de voorwaarde in de eerste parameter resulteert in waar.
```
Debug.WriteLineIf(iUnitQty > 50, "This message WILL appear")
Debug.WriteLineIf(iUnitQty < 50, "This message will NOT appear")
```
Gebruik de assert-methode van de Debug klasse zodat in het uitvoervenster alleen het bericht wordt weergegeven als een opgegeven voorwaarde resulteert in onwaar:
```
Debug.Assert(dUnitCost > 1, "Message will NOT appear")
Debug.Assert(dUnitCost < 1, "Message will appear")
```

Maak de TextWriterTraceListener objecten voor het consolevenster (tr1) en voor een tekstbestand met de naam Output.txt (tr2) en voeg vervolgens elk object toe aan de Debug Listeners verzameling:

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)

Gebruik voor leesbaarheid de Unindent methode om de inspringing te verwijderen voor volgende berichten die door de Debug klasse worden gegenereerd. Wanneer u de Indent en de Unindent methoden samen gebruikt, kan de lezer de uitvoer als groep onderscheiden.
```
Debug.Unindent()
Debug.WriteLine("Debug Information-Product Ending")
```
Als u ervoor wilt zorgen dat elk listenerobject alle uitvoer ontvangt, roept u de Flush methode aan voor de Debug klassebuffers:
```
Debug.Flush()
```

De traceringsklasse gebruiken

U kunt de Trace klasse ook gebruiken om berichten te produceren die de uitvoering van een toepassing bewaken. De Trace en Debug klassen delen de meeste van dezelfde methoden om uitvoer te produceren, waaronder:

WriteLine
WriteLineIf
Indent
Unindent
Assert
Flush

U kunt de Trace en de Debug klassen afzonderlijk of samen in dezelfde toepassing gebruiken. In een oplossingsconfiguratieproject voor foutopsporing zijn beide Trace en Debug uitvoer actief. Het project genereert uitvoer van beide klassen naar alle listenerobjecten. Een Release Solution Configuration-project genereert echter alleen uitvoer van een Trace klasse. Het project Release Solution Configuration negeert eventuele Debug aanroepen van klassemethoden.

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

Controleren of deze werkt

Zorg ervoor dat Foutopsporing de huidige oplossingsconfiguratie is.
Als het venster Solution Explorer niet zichtbaar is, drukt u op Ctrl+Alt+L om dit venster weer te geven.
Klik met de rechtermuisknop op conInfo en klik vervolgens op Eigenschappen.
Controleer in het linkerdeelvenster van de eigenschappenpagina conInfo onder de map Configuratie of de pijl verwijst naar Foutopsporing.
Klik boven de map Configuratie in de vervolgkeuzelijst Configuratie op Actief (foutopsporing) of Foutopsporing en klik vervolgens op OK.
Druk op Ctrl+Alt+O om het uitvoervenster weer te geven.
Druk op F5 om de code uit te voeren. Wanneer het dialoogvenster Assertion Failed wordt weergegeven, klikt u op Negeren.

Druk in het consolevenster op Enter. Het programma moet worden voltooid en in het uitvoervenster moet de volgende uitvoer worden weergegeven:

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

In het consolevenster en het bestand Output.txt moet de volgende uitvoer worden weergegeven:

(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

Volledige codevermelding

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

Probleemoplossing

Als het configuratietype van de oplossing release is, wordt de Debug klasse-uitvoer genegeerd.
Nadat u een TextWriterTraceListener klasse voor een bepaald doel hebt gemaakt, TextWriterTraceListener ontvangt u uitvoer van de Trace en de Debug klassen. Dit gebeurt ongeacht of u de Add methode van de Trace klasse of de Debug klasse gebruikt om aan de Listeners klasse toe te voegenTextWriterTraceListener.
Als u een listenerobject toevoegt voor hetzelfde doel in de Trace en de Debug klassen, wordt elke regel met uitvoer gedupliceerd, ongeacht Debug of de uitvoer wordt gegenereerd of Trace gegenereerd.
```
Dim tr1 As New TextWriterTraceListener(System.Console.Out)
Debug.Listeners.Add(tr1)
Dim tr2 As New TextWriterTraceListener(System.Console.Out)
Trace.Listeners.Add(tr2)
```

Verwijzingen

Feedback

Is deze pagina nuttig?

Last updated on 2024-07-30