Traçage et instrumentation d'applications

Le suivi est un moyen de surveiller l’exécution de votre application pendant son exécution . Vous pouvez ajouter l'instrumentation de traçage et de débogage à votre application .NET Framework au moment du développement, et utiliser cette instrumentation pendant le développement de l'application et après son déploiement. Utilisez les classes System.Diagnostics.Trace, System.Diagnostics.Debug et System.Diagnostics.TraceSource pour enregistrer les informations relatives aux erreurs et à l'exécution de l'application dans des journaux, des fichiers texte ou d'autres appareils en vue d'une analyse ultérieure.

Le terme instrumentation fait référence à la capacité de surveiller ou de mesurer le niveau de performance d’un produit et de diagnostiquer les erreurs éventuelles. En programmation, c'est la capacité d'une application à incorporer les éléments suivants :

• Suivi de code : réception de messages d’information sur l’exécution d’une application au moment de l’exécution.

• Débogage : repérage et résolution des erreurs de programmation dans une application en cours de développement. Pour plus d’informations, consultez Débogage.

• Compteurs de performance : composants qui vous permettent de suivre les performances de votre application. Pour plus d’informations, consultez Compteurs de performances.

• Journaux des événements : composants qui vous permettent de recevoir et de suivre les principaux événements liés à l’exécution de votre application. Pour plus d'informations, consultez la classe EventLog.

L'instrumentation de votre application, en plaçant des instructions de trace à des endroits stratégiques de votre code, est particulièrement utile pour les applications distribuées. Avec les instructions de trace, vous pouvez instrumenter une application pour afficher des informations en cas de problème, mais aussi pour surveiller les performances d'exécution de l'application.

La classe TraceSource fournit des fonctionnalités de suivi améliorées. Elle remplace les méthodes statiques des classes de traçage Trace et Debug plus anciennes. Les classes Trace et Debug familières sont toujours largement utilisées, mais la classe TraceSource est recommandée pour ses nouvelles commandes de traçage, telles que TraceEvent et TraceData.

Les classes Trace et Debug sont identiques, à ceci près que les procédures et les fonctions de la classe Trace ont compilées par défaut dans des versions release, mais celles de la classe Debug ne le sont pas.

Avec les classes Trace et Debug, vous pouvez surveiller et analyser les performances d'une application pendant le développement ou après le déploiement. Par exemple, utilisez la classe Trace pour suivre des actions particulières au fur et à mesure qu'elles se produisent dans une application déployée (comme la création de nouvelles connexions de base de données) et ainsi surveiller les performances de l'application.

Traçage et débogage de code

Pendant la phase de développement, utilisez les méthodes de sortie de la classe Debug pour afficher des messages dans la fenêtre Sortie de l'environnement de développement intégré (IDE) de Visual Studio. Par exemple :

Trace.WriteLine("Hello World!")
Debug.WriteLine("Hello World!")

System.Diagnostics.Trace.WriteLine("Hello World!");
System.Diagnostics.Debug.WriteLine("Hello World!");

Chacun de ces exemples affiche "Hello World!" dans la fenêtre Sortie quand l'application est exécutée dans le débogueur.

Cela vous permet de déboguer vos applications et d'optimiser leurs performances en fonction de leur comportement dans votre environnement de test. Déboguez votre application dans votre version debug en activant l'attribut conditionnel Debug pour recevoir toutes les données de sortie de débogage. Une fois que votre application est finalisée, compilez votre version release sans activer l’attribut conditionnel Debug. Ainsi, le compilateur n’inclura pas votre code de débogage dans le fichier exécutable final. Pour plus d’informations, consultez Guide pratique pour effectuer une compilation conditionnelle avec Trace et Debug. Pour plus d’informations sur les différentes configurations de build de votre application, consultez Compilation et génération.

Vous pouvez aussi tracer l'exécution du code dans une application installée, en utilisant les méthodes de la classe Trace. En plaçant des Commutateurs de suivi dans votre code, vous pouvez contrôler le traçage et son importance. Vous pouvez ainsi surveiller l’état de votre application dans un environnement de production, ce qui est particulièrement important dans une application qui utilise plusieurs composants s’exécutant sur plusieurs ordinateurs. Vous pouvez contrôler la manière dont les commutateurs sont utilisés après le déploiement par le biais du fichier de configuration. Pour plus d’informations, consultez Guide pratique pour créer, initialiser et configurer des commutateurs de suivi.

Quand vous développez une application pour laquelle vous envisagez d'utiliser la fonctionnalité de traçage, vous incluez généralement des messages de traçage et de débogage dans le code de l'application. Quand vous êtes prêt à déployer l’application, compilez votre build de mise en production sans activer l’attribut conditionnel Debug. Cependant, vous pouvez activer l’attribut conditionnel Trace pour que le compilateur inclue votre code de suivi dans le fichier exécutable. Pour plus d’informations, consultez Guide pratique pour effectuer une compilation conditionnelle avec Trace et Debug.

Phases du traçage de code

Le traçage de code comprend les trois phases suivantes :

1. Instrumentation : vous ajoutez le code de suivi à votre application.

2. Suivi : le code de suivi écrit les informations vers la cible spécifiée.

3. Analyse : vous évaluez les informations de suivi pour identifier et comprendre les problèmes potentiels dans l’application.

Durant le développement, toutes les méthodes de sortie de débogage et de traçage écrivent les informations par défaut dans la fenêtre Sortie de Visual Studio. Dans une application déployée, les méthodes écrivent les informations de traçage vers les cibles de votre choix. Pour plus d’informations sur la spécification d’une cible de sortie pour le suivi ou le débogage, consultez Écouteurs de suivi.

La section suivante décrit les principales étapes généralement suivies lors du traçage pour analyser et corriger des problèmes potentiels dans des applications déployées. Pour plus d'informations sur ces étapes, voir les liens appropriés.

Pour utiliser le traçage dans une application

1. Déterminez la sortie de traçage que vous souhaitez obtenir sur place après avoir déployé l'application.

2. Créez un jeu de commutateurs. Pour plus d’informations, consultez Procédure : Configurer des commutateurs de Trace.

3. Ajoutez les instructions de trace au code de l'application.

4. Déterminez l'emplacement d'affichage de la sortie de traçage et ajoutez les écouteurs appropriés. Pour plus d’informations, consultez Création et initialisation d’écouteurs de suivi.

5. Testez et déboguez votre application ainsi que le code de trace qu'elle contient.

6. Compilez l'application en code exécutable, en suivant l'une des procédures ci-dessous :

   • Utilisez le menu Générer et la page Déboguer de la boîte de dialogue Pages de propriétés dans l’Explorateur de solutions. Procédez ainsi pour compiler votre application dans Visual Studio.

     - ou -

   • Utilisez les directives du compilateur Trace et Debug pour la méthode de ligne de commande de compilation. Pour plus d’informations, consultez Compilation conditionnelle avec Trace et Debug. Procédez ainsi pour compiler votre application à partir d'une ligne de commande.

7. Si un problème survient au moment de l'exécution, activez le commutateur de trace approprié. Pour plus d’informations, consultez Configuration des commutateurs de suivi.

   Le code de trace écrit les messages de traçage vers la cible spécifiée (par exemple, un écran, un fichier texte ou un journal des événements). Cette cible est déterminée par le type d’écouteur que vous avez inclus dans la collection Trace.Listeners.

8. Analysez les messages de traçage pour identifier et comprendre les problèmes potentiels dans l'application.

Instrumentation de traçage pour les applications distribuées

Pendant la phase de création d'une application distribuée, il peut être difficile de tester l'application dans des conditions d'utilisation réelles. Les équipes de développement ont rarement la possibilité de tester toutes les combinaisons de systèmes d'exploitation ou de navigateurs web (y compris toutes les versions localisées) ou de simuler un nombre élevé d'utilisateurs qui accéderont simultanément à l'application. Vous ne pouvez donc pas tester la manière dont une application distribuée répondra à un fort trafic, à des configurations différentes et aux comportements propres à chaque utilisateur final. Par ailleurs, vous ne pouvez pas interagir directement avec toutes les parties de l'application distribuée, ni afficher leur activité, car beaucoup d'entre elles ne possèdent pas l'interface utilisateur nécessaire.

Vous pouvez cependant contourner ce problème en permettant aux applications distribuées de décrire certains événements utiles pour les administrateurs système, en particulier les problèmes rencontrés. Il vous suffit d’instrumenter l’application, c’est-à-dire de placer des instructions de suivi à des endroits stratégiques de votre code. Ainsi, si l'application a un comportement inattendu au moment de l'exécution (par exemple, un temps de réponse très lent), vous pouvez en déterminer la cause probable.

Grâce aux instructions de trace, vous ne perdez pas de temps à analyser, modifier et recompiler le code source d’origine, ni à essayer de reproduire l’erreur d’exécution dans l’environnement de débogage. Rappelez-vous que l'instrumentation d'une application est utile pour afficher les erreurs, mais aussi pour surveiller les performances.

Placement stratégique des instructions de trace

Choisissez avec soin les endroits où vous allez placer les instructions de trace qui seront utilisées au moment de l'exécution. Vous devez déterminer quelles informations de traçage seront les plus utiles dans une application déployée afin que tous les scénarios de traçage probables soient traités de manière adéquate. Les applications utilisant la fonctionnalité de traçage étant très diverses, il n'existe pas d'instructions générales pour placer stratégiquement des instructions de trace. Pour plus d’informations sur la façon de placer des instructions de suivi, consultez Guide pratique pour ajouter des instructions de suivi au code d’application.

Sortie de trace

La sortie de suivi est collectée par des objets appelés écouteurs. Un écouteur est un objet qui reçoit la sortie de trace et qui l'écrit dans une cible de sortie (généralement une fenêtre, un journal ou un fichier texte). Quand un écouteur de la trace est créé, il est en principe ajouté à la collection Trace.Listeners, ce qui permet à l’écouteur de recevoir toutes les données de sortie de trace.

Les informations de traçage sont toujours écrites au moins dans la cible de sortie Trace par défaut (DefaultTraceListener). Si, pour une raison quelconque, vous avez supprimé l'écouteur DefaultTraceListener sans avoir ajouté d'autres écouteurs à la collection Listeners, vous ne recevrez plus de messages de trace. Pour plus d’informations, consultez Écouteurs de suivi.

Les six membres Debug et méthodes Trace qui écrivent des informations de traçage sont répertoriés dans le tableau suivant.

Tous les écouteurs dans la collection Listeners reçoivent les messages décrits dans le tableau ci-dessus, mais les actions prises dépendent du type d'écouteur qui reçoit le message. Par exemple, DefaultTraceListener affiche une boîte de dialogue d’assertion quand il reçoit une notification Fail ou une notification Assert d’échec, mais TextWriterTraceListener écrit simplement la sortie dans son flux.

Vous pouvez générer des résultats personnalisés en implémentant votre propre écouteur. Par exemple, créez un écouteur de la trace personnalisé qui affiche les messages dans une boîte de message ou qui se connecte à une base de données pour ajouter les messages à une table. Tous les écouteurs personnalisés doivent prendre en charge les six méthodes mentionnées ci-dessus. Pour plus d'informations sur la création d'écouteurs définis par le développeur, voir TraceListener dans la documentation .NET Framework.

Les méthodes Write et WriteLine écrivent toujours le texte que vous spécifiez. Assert, WriteIf et WriteLineIf nécessitent un argument Boolean qui contrôle si elles écrivent le texte spécifié. Elles écrivent le texte spécifié uniquement si l’expression a la valeur true (pour WriteIf et WriteLineIf), ou false (pour Assert). La méthode Fail écrit toujours le texte spécifié. Pour plus d’informations, consultez Guide pratique pour ajouter des instructions de suivi au code d’application et la référence .NET Framework.

Problèmes de sécurité

Si vous ne désactivez pas le traçage et le débogage avant de déployer votre application ASP.NET, celle-ci peut dévoiler des informations exploitables par un programme malveillant. Pour plus d’informations, consultez Guide pratique pour effectuer une compilation conditionnelle avec Trace et Debug, Compilation et génération et Guide pratique pour créer, initialiser et configurer des commutateurs de suivi. Vous pouvez également configurer le débogage via IIS (Internet Information Services).

Voir aussi

• Trace
• TraceSource
• Contrats de code
• Types de projets C#, F# et Visual Basic
• Procédure : Ajouter des instructions de trace dans le code d’une application
• Procédure : Effectuer une compilation conditionnelle avec Trace et Debug
• Procédure : Créer, initialiser et configurer les commutateurs de trace
• Procédure : Créer et initialiser des sources de trace
• Procédure : Utiliser des TraceSource et des filtres avec des écouteurs de trace
• Écouteurs de suivi
• Commutateurs de traçage