Introduction à l'instrumentation et au traçage
Le terme instrumentation fait référence à la capacité de contrôler ou de mesurer le niveau de performance d'un produit et de diagnostiquer les erreurs éventuelles. Dans le monde de la programmation, il s'agit de la capacité d'une application à incorporer les éléments suivants :
Traçage de code – Réception de messages informatifs sur l'exécution d'une application au moment de l'exécution.
Débogage – Traçage et résolution d'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 tracer les performances de votre application. Pour plus d'informations, consultez Introduction to Monitoring Performance Thresholds.
Journaux des événements - Composants qui vous permettent de recevoir et de tracer les principaux événements de l'exécution de votre application. Pour plus d'informations, consultez la classe EventLog.
Les classes Trace et Debug vous permettent de contrôler et d'examiner les performances d'une application lors du développement ou après le déploiement. Par exemple, vous pouvez utiliser la classe Trace pour suivre des actions particulières dans une application déployée au fur et à mesure qu'elles se produisent (par exemple, la création de nouvelles connexions de base de données) et ainsi contrôler l'efficacité de l'application.
Traçage de code et débogage
Pendant le développement, vous pouvez utiliser 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, Integrated Development Environment) 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!");
System.Diagnostics.Trace.WriteLine("Hello World!");
System.Diagnostics.Debug.WriteLine("Hello World!");
Chacun de ces exemples affiche "Hello World!" dans la fenêtre Sortie lorsque 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. Vous pouvez déboguer votre application dans votre version Debug en activant l'attribut conditionnel Debug pour recevoir toutes les données de sortie de débogage. Lorsque votre application est prête pour la version Release, vous pouvez compiler votre version Release sans activer l'attribut conditionnel Debug afin que le compilateur n'inclue pas votre code de débogage dans le fichier exécutable final. Pour plus d'informations, consultez Comment : effectuer une compilation conditionnelle avec Trace et Debug. Pour plus d'informations sur les différentes configurations de build de votre application, consultez Génération dans Visual Studio.
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 Commutateurs de traçage dans votre code, vous pouvez contrôler si le traçage se produit et jusqu'à quel point. Cela vous permet de contrôler l'état de votre application dans un environnement de production. Cela est particulièrement important dans le cas d'une application professionnelle qui utilise plusieurs composants 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 Comment : configurer les commutateurs de trace.
Lorsque vous développez une application pour laquelle vous envisagez d'utiliser la fonctionnalité de traçage, vous incluez généralement des messages de trace et de débogage dans le code de l'application. Lorsque vous êtes prêt à déployer l'application, vous pouvez compiler votre version Release sans activer l'attribut conditionnel Debug. Cependant, vous pouvez activer l'attribut conditionnel Trace pour que le compilateur inclue votre code de traçage dans le fichier exécutable. Pour plus d'informations, consultez Comment : effectuer une compilation conditionnelle avec Trace et Debug.
Phases du traçage de code
Le traçage de code comprend trois phases :
Instrumentation — Vous ajoutez le code de traçage à votre application.
Traçage — Le code de traçage écrit les informations dans la cible spécifiée.
Analyse — Vous évaluez les informations de traçage pour identifier et comprendre les problèmes dans l'application.
Lors du développement, toutes les méthodes de sortie de débogage et de traçage écrivent par défaut des informations dans la fenêtre Sortie dans Visual Studio. Dans une application déployée, les méthodes écrivent les informations de traçage vers les cibles spécifiées. Pour plus d'informations sur la spécification d'une cible de sortie pour le traçage ou le débogage, consultez Écouteurs de la trace.
Instrumentation de traçage et applications distribuées
Lorsque vous créez une application distribuée, il peut être difficile de la tester de manière réaliste. Peu d'équipes de développement ont la possibilité de tester toutes les combinaisons de systèmes d'exploitations ou de navigateurs Web (y compris toutes les versions localisées) ou de simuler le nombre élevé d'utilisateurs qui accéderont simultanément à l'application. Dans ces circonstances, vous ne pouvez pas tester la manière dont une application répondra à des volumes élevés, à différentes configurations et à des comportements d'utilisateurs finals uniques. De même, de nombreuses portions d'une application distribuée ne possèdent pas d'interface utilisateur avec laquelle vous pouvez interagir directement ou afficher l'activité de ces portions.
Vous pouvez cependant pallier cette déficience en permettant aux applications distribuées de décrire certains événements intéressants aux administrateurs système, et plus particulièrement les problèmes, en instrumentant l'application — c'est-à-dire en plaçant des instructions de traçage à des endroits spécifiques de votre code. Si un comportement inattendu se produit au moment de l'exécution (par exemple, un temps de réponse extrêmement lent), vous pouvez en déterminer la cause probable.
Grâce aux instructions de traçage, vous n'avez pas besoin d'examiner le code source d'origine, de le modifier, de le recompiler et d'essayer de reproduire l'erreur d'exécution dans l'environnement de débogage. Rappelez-vous que vous pouvez instrumenter une application non seulement pour afficher des erreurs, mais aussi pour analyser les performances.
Placement stratégique des instructions de traçage
Vous devez faire preuve de prudence lorsque vous placez des instructions de traçage qui seront utilisées au moment de l'exécution. Vous devez déterminer les informations de traçage qui 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 diversifiées, il n'existe pas de directives générales pour placer stratégiquement des instructions de traçage. Pour plus d'informations sur la façon de placer des instructions de traçage, consultez Comment : ajouter des instructions de traçage dans le code d'une application.
Sortie du traçage
La sortie du traçage est recueillie par des objets appelés écouteurs. Un écouteur est un objet qui reçoit la sortie du traçage et qui l'écrit sur un périphérique de sortie (généralement une fenêtre, un journal ou un fichier texte). Lorsqu'un écouteur de la trace est créé, il est généralement ajouté à la collection Trace.Listeners, ce qui permet à l'écouteur de recevoir toutes les données de sortie du traçage.
Les informations de traçage sont au minimum toujours écrites 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 pourrez pas recevoir de messages de trace. Pour plus d'informations, consultez Écouteurs de la trace.
Les six méthodes Debug Members et Trace qui écrivent des informations de traçage sont répertoriées dans le tableau suivant.
Méthode |
Sortie |
|---|---|
Assert |
Le texte spécifié ou, si aucun texte n'est spécifié, la pile des appels. La sortie est uniquement écrite si la condition spécifiée en tant qu'argument dans l'instruction Assert a la valeur false. |
Échec |
Le texte spécifié ou, si aucun texte n'est spécifié, la pile des appels. |
Écriture |
Le texte spécifié. |
WriteIf |
Le texte spécifié si la condition spécifiée en tant qu'argument dans l'instruction WriteIf est satisfaite. |
WriteLine |
Le texte spécifié et un retour chariot. |
WriteLineIf |
Le texte spécifié et un retour chariot si la condition spécifiée en tant qu'argument dans l'instruction WriteLineIf est satisfaite. |
Tous les écouteurs dans la collection Listeners reçoivent les messages décrits dans le tableau ci-dessus, mais les actions prises peuvent varier en fonction du type d'écouteur qui reçoit le message. Par exemple, l'écouteur DefaultTraceListener affiche une boîte de dialogue d'assertion lorsqu'il reçoit une notification Fail ou une notification Assert échouée, mais un écouteur TextWriterTraceListener écrit simplement la sortie dans son flux.
Vous pouvez générer des résultats personnalisés en implémentant votre propre écouteur. Un écouteur de la trace personnalisé peut, par exemple, afficher les messages dans une boîte de message ou se connecter à une base de données pour ajouter des messages dans un tableau. Tous les écouteurs personnalisés devraient 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, consultez TraceListener, dans le manuel de référence de Microsoft .NET Framework.
.gif "Remarque pour Visual Basic") Remarque pour Visual Basic |
|---|
Dans Visual Basic 2005, les méthodes Debug.Write, Debug.WriteIf, Debug.WriteLineet Debug.WriteLineIf ont remplacé la méthode Debug.Print qui était disponible dans les versions antérieures de Visual Basic. |
Les méthodes Write et WriteLine écrivent toujours le texte que vous spécifiez. Assert, WriteIf et WriteLineIf requièrent un argument Boolean qui contrôle si elles écrivent le texte spécifié ; elles n'écrivent le texte spécifié que si l'expression est true (pour WriteIf et WriteLineIf), ou false (pour Assert). La méthode Fail écrit toujours le texte spécifié. Pour plus d'informations, consultez Comment : ajouter des instructions de traçage dans le code d'une application et le manuel de référence du .NET Framework.
Considérations relatives à la 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 nuisible. Pour plus d'informations, consultez Comment : effectuer une compilation conditionnelle avec Trace et Debug, Génération dans Visual Studio et Comment : configurer les commutateurs de trace. Vous pouvez également configurer le débogage par les services IIS (Internet Information Services).
Voir aussi
Tâches
Comment : ajouter des instructions de traçage dans le code d'une application
Comment : configurer les commutateurs de trace