Trace et débogage en Visual C sharp

2024-12-14

Cet article explique comment tracer et déboguer en Visual C# et fournit des exemples d’étapes pour expliquer les informations associées.

Version du produit d’origine : Visual C#
Numéro de base de connaissances d’origine : 815788

Résumé

Pour obtenir une version Microsoft Visual Basic .NET de cet article, consultez Utiliser des classes Trace et Debug dans Visual Basic .NET.

Cet article fait référence au système d’espace de noms bibliothèque de classes .NET Framework. Diagnostics et décrit comment utiliser les Debug classes et les Trace classes. Ces classes sont disponibles dans .NET Framework. Vous pouvez utiliser ces classes pour fournir des informations sur les performances d’une application pendant le développement d’applications ou après le déploiement en production. Ces classes ne font qu’une partie des fonctionnalités d’instrumentation disponibles dans le .NET Framework.

Spécifications

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

Microsoft Windows
Microsoft Visual C#

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 section Debug Class 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 est exécuté, vous pouvez utiliser des méthodes de la Debug classe pour produire des messages qui vous aident à surveiller la séquence d’exécution du programme, à 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) Visual Studio.

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

Lorsque 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 à l’utilisateur. La boîte de dialogue inclut le message, le nom du projet et le Debug. Numéro de l’instruction Assert. La boîte de dialogue inclut également les trois boutons de commande suivants :

Abandon : l’application cesse de s’exécuter.
Nouvelle tentative : l’application entre en mode débogage.
Ignorer : l’application se poursuit. L’utilisateur doit cliquer sur l’un de ces boutons avant 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 d’écouteurs qui inclut des Listener objets.

Chaque objet écouteur surveille Debug la sortie et dirige la sortie vers une cible spécifiée.

Chaque écouteur de la collection Listener reçoit toutes les sorties générées par la Debug classe. Utilisez la TextWriterTraceListener classe pour définir des Listener objets. 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 (.txt) à l’aide de l’instruction System.IO.File.CreateText("FileName.txt") . Après avoir créé un TextWriterTraceListener objet, vous devez ajouter l’objet au Debug. Collection d’écouteurs pour recevoir Debug la sortie.

Créer un exemple avec la classe de débogage

Démarrez Visual Studio ou Visual C# Express Edition.
Créez un projet d’application console Visual C# nommé conInfo. La classe 1 est créée dans Visual Studio .NET. Program.cs est créé dans Visual Studio 2005.
Ajoutez l’espace de noms suivant en haut de la classe1 ou Program.cs.
```
using System.Diagnostics;
```
Pour initialiser des variables pour contenir des informations sur un produit, ajoutez les instructions de déclaration suivantes à la méthode Main :
```
string sProdName = "Widget";
int iUnitQty = 100;
double dUnitCost = 1.03;
```
Spécifiez le message que la classe produit en tant que 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 une 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.ToString());
Debug.WriteLine("The per unit cost is " + dUnitCost.ToString());

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 System.Xml.XmlDocument de noms dans la fenêtre Sortie :
```
System.Xml.XmlDocument oxml = new System.Xml.XmlDocument();
Debug.WriteLine(oxml);
```
Pour organiser la sortie, vous pouvez inclure une catégorie comme paramètre d’entrée facultatif, deuxième entrée de la WriteLine méthode. Si vous spécifiez une catégorie, le format du message de la fenêtre Sortie est « catégorie : 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.ToString(),"Field");
Debug.WriteLine("Total Cost is " + (iUnitQty * dUnitCost),"Calc");
```
La fenêtre Sortie ne peut afficher les 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 WriteLineIf est le message qui s’affiche uniquement si la condition dans le 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 pour 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 since dUnitcost < 1 is false");
```

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

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

Pour une lisibilité, utilisez la Unindent méthode pour supprimer la mise en retrait pour les messages suivants générés par la Debug classe. Lorsque vous utilisez ensemble les méthodes et les Indent Unindent méthodes, le lecteur peut distinguer la sortie en tant que groupe.
```
Debug.Unindent();
Debug.WriteLine("Debug Information-Product Ending");
```
Pour vous assurer que chaque Listener objet reçoit toute sa sortie, appelez la méthode Flush pour les Debug mémoires tampons de classe :
```
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 partagent Debug la plupart des mêmes méthodes pour produire une sortie, notamment les suivantes :

WriteLine
WriteLineIf
Tiret
Unindent
Assert
Purge

Vous pouvez utiliser les Trace classes et Debug les classes séparément ou ensemble dans la même application. Dans un projet Debug Solution Configuration, les deux Trace et Debug la sortie sont actives. Le projet génère la sortie de ces deux classes vers tous les Listener objets. 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érifiez qu’elle fonctionne

Assurez-vous que Le débogage 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 le débogage.

Note

Dans Visual C# 2005 et dans Visual C# 2005 Express Edition, cliquez sur Déboguer dans la page conInfo.
Au-dessus du dossier Configuration, dans la zone de liste déroulante Configuration, cliquez sur Active (Debug) ou Debug, puis sur OK. Dans Visual C# 2005 et dans Visual C# 2005 Express Edition, cliquez sur Active (Déboguer) ou Déboguer dans la zone de liste déroulante Configuration de la page Débogage , puis cliquez sur Enregistrer dans le menu Fichier .
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 Assertion Failed 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 qui ressemble à ce qui suit :

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

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

Note

Le fichier Output.txt se trouve dans le même répertoire que l’exécutable conInfo (conInfo.exe). En règle générale, il s’agit du dossier \bin dans lequel la source du projet est stockée. (C:\Documents and Settings\User login\My Documents\Visual Studio Projects\conInfo\bin par défaut). Dans Visual C# 2005 et dans Visual C# 2005 Express Edition, le fichier Output.txt se trouve dans le dossier : C:\Documents and Settings\User login\My Documents\Visual Studio 2005\Projects\conInfo\conInfo\bin\Debug.

Liste complète du code

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

Résolution des problèmes

Si le type de configuration de la solution est Release, la Debug sortie de classe est ignorée.
Après avoir créé une TextWriterTraceListener classe pour une cible particulière, TextWriterTraceListener reçoit la sortie des classes et des Debug Trace classes. Cela se produit, que vous utilisiez la Add méthode de la Trace classe ou la Debug classe à ajouter TextWriterTraceListener à la Listeners classe.

Si vous ajoutez un Listeners objet pour la même cible dans les Trace classes et les Debug classes, chaque ligne de sortie est dupliquée, que la sortie soit générée ou Trace nonDebug.

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

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

Partager via