Utiliser des classes Trace et Debug dans Visual Basic .NET

Article
03/20/2024

Cet article fournit des informations sur l’utilisation des Debug classes et Trace dans Visual Basic .NET.

Version d’origine du produit : Visual Basic .NET
Numéro de la base de connaissances d’origine : 313417

Résumé

Cet article montre comment utiliser les Debug classes et Trace . Ces classes sont disponibles dans Microsoft .NET Framework. Vous pouvez utiliser ces classes pour fournir des informations sur les performances d’une application pendant le développement de l’application ou après le déploiement en production. Ces classes ne sont qu’une partie des fonctionnalités d’instrumentation disponibles dans le .NET Framework.

Configuration requise

La liste suivante décrit le matériel, les logiciels, l’infrastructure réseau et les Service Packs recommandés dont vous avez besoin :

Windows
Visual Basic .NET

Cet article suppose également que vous êtes familiarisé avec le débogage de programme.

Description de la technique

Les étapes de la section Créer un exemple avec la classe Debug montrent comment créer une application console qui utilise la Debug classe pour fournir des informations sur l’exécution du programme.

Lorsque le programme s’exécute, vous pouvez utiliser les méthodes de la Debug classe pour produire des messages qui aident à surveiller, à détecter les dysfonctionnements ou à fournir des informations de mesure des performances. Par défaut, les messages générés par la Debug classe apparaissent dans la fenêtre Sortie de l’environnement de développement intégré (IDE) Microsoft Visual Studio.

L’exemple de code utilise la WriteLine méthode pour produire un message suivi d’une marque de fin de ligne. Lorsque vous utilisez cette méthode pour produire un message, chaque message apparaît sur une ligne distincte dans la fenêtre Sortie.

Si vous utilisez la Assert méthode de la Debug classe , la fenêtre Sortie affiche un message uniquement si une condition spécifiée prend la valeur false. Le message s’affiche également dans une boîte de dialogue modale pour l’utilisateur. La boîte de dialogue inclut le message, le nom du projet et le numéro de l’instruction Debug.Assert . La boîte de dialogue comprend également trois boutons de commande :

Abandon : l’application cesse de s’exécuter.
Nouvelle tentative : l’application passe en mode débogage.
Ignorer : l’application continue. L’utilisateur doit cliquer sur l’un de ces boutons pour que l’application puisse continuer.

Vous pouvez également diriger la sortie de la Debug classe vers des destinations autres que la fenêtre Sortie. La Debug classe possède une collection nommée Listeners qui inclut des objets Listener. Chaque objet Listener surveille la Debug sortie et dirige la sortie vers une cible spécifiée. Chaque écouteur de la Listeners collection reçoit toute sortie générée par la Debug classe. Utilisez la TextWriterTraceListener classe pour définir des objets Listener. Vous pouvez spécifier la cible d’une TextWriterTraceListener classe par le biais de son constructeur. Voici quelques cibles de sortie possibles :

Fenêtre console à l’aide de la System.Console.Out propriété .
Fichier texte à l’aide de l’instruction System.IO.File.CreateText("FileName.txt")) .

Après avoir créé un TextWriterTraceListener objet, vous devez ajouter l’objet à la collection pour recevoir Debug la Debug.Listeners sortie.

Créer un exemple avec la classe Debug

Utilisez Visual Basic .NET pour créer un projet d’application console nommé conInfo. Un module public nommé Module1 est ajouté au projet par défaut.
Pour initialiser des variables afin qu’elles contiennent des informations sur un produit, ajoutez les instructions suivantes Dim :
```
Dim sProdName As String = "Widget"
Dim iUnitQty As Integer = 100
Dim dUnitCost As Decimal = 1.03
```
Spécifiez le message que la classe produit comme premier paramètre d’entrée de la WriteLine méthode . Appuyez sur la combinaison de touches Ctrl+Alt+O pour vous assurer que la fenêtre Sortie est visible.
```
Debug.WriteLine("Debug Information-Product Starting ")
```
Pour plus de lisibilité, utilisez la Indent méthode pour mettre en retrait les messages suivants dans la fenêtre Sortie :
```
Debug.Indent()
```

Pour afficher le contenu des variables sélectionnées, utilisez la WriteLine méthode comme suit :

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

Vous pouvez également utiliser la WriteLine méthode pour afficher l’espace de noms et le nom de classe d’un objet existant. Par exemple, le code suivant affiche l’espace de System.Xml.XmlDocument noms dans la fenêtre Sortie :
```
Dim oxml As New System.Xml.XmlDocument()
Debug.WriteLine(oxml)
```
Pour organiser la sortie, vous pouvez inclure une catégorie en tant que deuxième paramètre d’entrée facultatif de la WriteLine méthode. Si vous spécifiez une catégorie, le format du message de la fenêtre Sortie est « category : message ». Par exemple, la première ligne du code suivant affiche « Champ : le nom du produit est Widget » dans la fenêtre Sortie :
```
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 fenêtre Sortie ne peut afficher des messages que si une condition désignée prend la valeur true à l’aide de la WriteLineIf méthode de la Debug classe . La condition à évaluer est le premier paramètre d’entrée de la WriteLineIf méthode . Le deuxième paramètre de WriteLineIf est le message qui s’affiche uniquement si la condition du premier paramètre prend la valeur true.
```
Debug.WriteLineIf(iUnitQty > 50, "This message WILL appear")
Debug.WriteLineIf(iUnitQty < 50, "This message will NOT appear")
```
Utilisez la méthode Assert de la Debug classe afin que la fenêtre Sortie affiche le message uniquement si une condition spécifiée prend la valeur false :
```
Debug.Assert(dUnitCost > 1, "Message will NOT appear")
Debug.Assert(dUnitCost < 1, "Message will appear")
```

Créez les TextWriterTraceListener objets pour la fenêtre console (tr1) et pour un fichier texte nommé Output.txt (tr2), puis ajoutez chaque objet à la DebugListeners collection :

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)

Pour plus de lisibilité, utilisez la Unindent méthode pour supprimer la mise en retrait des messages suivants générés par la Debug classe. Lorsque vous utilisez les IndentUnindent méthodes et ensemble, le lecteur peut distinguer la sortie en tant que groupe.
```
Debug.Unindent()
Debug.WriteLine("Debug Information-Product Ending")
```
Pour vous assurer que chaque objet Listener reçoit toute sa sortie, appelez la Flush méthode pour les mémoires tampons de classe Debug :
```
Debug.Flush()
```

Utilisation de la classe Trace

Vous pouvez également utiliser la Trace classe pour produire des messages qui surveillent l’exécution d’une application. Les Trace classes et Debug partagent la plupart des mêmes méthodes pour produire une sortie, notamment :

WriteLine
WriteLineIf
Indent
Unindent
Assert
Flush

Vous pouvez utiliser les TraceDebug classes et séparément ou ensemble dans la même application. Dans un projet Debug Solution Configuration, et TraceDebug la sortie sont actifs. Le projet génère la sortie de ces deux classes vers tous les objets Listener. Toutefois, un projet Release Solution Configuration génère uniquement la sortie d’une Trace classe. Le projet Release Solution Configuration ignore les Debug appels de méthode de 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()

Vérifier que cela fonctionne

Assurez-vous que Debug est la configuration actuelle de la solution.
Si la fenêtre Explorateur de solutions n’est pas visible, appuyez sur la combinaison de touches Ctrl+Alt+L pour afficher cette fenêtre.
Cliquez avec le bouton droit sur conInfo, puis cliquez sur Propriétés.
Dans le volet gauche de la page de propriétés conInfo , sous le dossier Configuration , vérifiez que la flèche pointe vers Débogage.
Au-dessus du dossier Configuration , dans la zone de liste déroulante Configuration, cliquez sur Actif (Déboguer) ou Déboguer, puis cliquez sur OK.
Appuyez sur Ctrl+Alt+O pour afficher la fenêtre Sortie.
Appuyez sur la touche F5 pour exécuter le code. Lorsque la boîte de dialogue Échec de l’assertion s’affiche, cliquez sur Ignorer.

Dans la fenêtre Console, appuyez sur Entrée. Le programme doit se terminer et la fenêtre Sortie doit afficher la sortie suivante :

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 fenêtre console et le fichier Output.txt doivent afficher la sortie suivante :

(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

Liste complète du code

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

Résolution des problèmes

Si le type de configuration de solution est Release, la sortie de classe Debug est ignorée.
Après avoir créé une TextWriterTraceListener classe pour une cible particulière, TextWriterTraceListener reçoit la Trace sortie des classes et Debug . Cela se produit que vous utilisiez la Add méthode de ou la TraceDebug classe à ajouter TextWriterTraceListener à la Listeners classe .
Si vous ajoutez un objet Listener pour la même cible dans les TraceDebug classes et , chaque ligne de sortie est dupliquée, que la sortie soit générée ou Trace nonDebug.
```
Dim tr1 As New TextWriterTraceListener(System.Console.Out)
Debug.Listeners.Add(tr1)
Dim tr2 As New TextWriterTraceListener(System.Console.Out)
Trace.Listeners.Add(tr2)
```