.Net : Utilisation des attributs de débogage

Ronald Vasseur

Le Framework .Net contient des attributs qui vont permettre de modifier et de personnaliser le rendu des données et le comportement du debugger. Cela va permettre par exemple d'améliorer la visibilité des données, d'empêcher le debugger d'entrer dans certaines méthodes ou encore de masquer des informations au debugger.

- Titre : .Net : Utilisation des attributs de débogage

- Auteur : Ronald Vasseur

- Parution : 31 octobre 2010

- Licence : Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright ® 2010 Ronald Vasseur. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- I. Modifier l'affichage dans le debugger

- I-A. DebuggerDisplayAttribute

- I-B. DebuggerBrowsableAttribute

- II. Modifier le comportement du debugger

- II-A. Mode de débogage Just My Code

- II-B. DebuggerHiddenAttribute

- II-C. DebuggerStepThroughAttribute

- II-D. DebuggerNonUserCodeAttribute

- III. Conclusion

- IV. Ressources

- Liens vers le MSDN

- Liens vers Developpez.com

I - Modifier l'affichage dans le debugger

Voyons comment modifier l'information qui va être affichée dans la fenêtre du debugger. Le but de ces modifications va être par exemple de rendre plus lisibles ou plus compréhensibles des données dont le nom ou la présentation dans le debugger ne sont pas "developer-friendly".

Microsoft .Net

I-A - DebuggerDisplayAttribute

Cet attribut peut être appliqué à une classe, à un délégué, une énumération, un champ ou une propriété. Il n'existe qu'une seule version du constructeur qui prend en paramètre une chaîne de caractères destinées à spécifier le format de l'affichage des données dans le debugger. Prenons l'exemple d'une propriété nommée Year de la classe Developer dont on souhaite préciser la signification dans le debugger. Voyons comment procéder :

Voici le code initial de la classe Developer :

La classe Developer

public class Developer
{
public Int16 Year { get; set; }

public String FirstName { get; set; }
public String Name { get; set; }

public Developer(string firstname, string name, Int16 year)
{
this.FirstName = firstname;
this.Name = name;
this.Year = year;
}
}

En l'état le debugger affiche la propriété Year comme le montre la capture suivante :

Propriété normale

Le but est de modifier le rendu dans le debugger pour afficher le texte suivant pour la propriété Year :
" Xxxxxx joined the company in xxxx "

Pour arriver à ce résultat il va falloir ajouter l'attribut DebuggerDisplay au-dessus de la propriété Year

Classe Developer avec DebuggerDisplayAttribute

public class Developer
{
[DebuggerDisplay("{FirstName} joined the company in {Year}")]
public Int16 Year { get; set; }

public String FirstName { get; set; }
public String Name { get; set; }

public Developer(string firstname, string name, Int16 year)
{
this.FirstName = firstname;
this.Name = name;
this.Year = year;
}
}

La chaine est passée directement à l'attribut et l'on a plus qu'à mettre entre accolades les membres de l'instance que l'on souhaite afficher. Il est également possible d'avoir un affichage plus complexe avec des expressions validant des conditions, je vous renvoie à la documentation MSDN si vous souhaitez connaître de manière exhaustive les possibilités du DebuggerDisplayAttribute.

Affiche personnalisé

I-B - DebuggerBrowsableAttribute

Cet attribut est complémentaire du précédent, il détermine comment vont être affichées les données dans la fenêtre du debugger. Cet attribut possède trois états qui sont les suivants :

- Never : n'affiche pas l'élément.

- Collapsed : affiche l'élément comme réduit.

- RootHidden : n'affiche pas l'élément racine

Prenons comme exemple une liste de chaînes de caractères et voyons comment en modifier l'affichage dans le debugger avec cet attribut.

Tout d'abord sans attribut le debugger va afficher cette liste comme suit :

Avec DebuggerBrowsable à Never

N'affiche pas l'élément

Avec DebuggerBrowsable à Never

Affiche l'élément réduit

Avec DebuggerBrowsable à Never

N'affiche pas l'élément racine

Il est ainsi possible de rendre l'exploration d'objets dans le debugger plus simple et rapide.

II - Modifier le comportement du debugger

II-A - Mode de débogage Just My Code

Just My Code est un mode de débogage qui permet de masquer le code non-utilisateur, c'est-à-dire le code que vous n'avez pas écrit (appels systèmes par exemple) ou qui a été spécifié comme tel par le biais de l'attribut DebuggerNonUserCodeAttribute.

Cette option du debugger s'active de la manière suivante :

- Dans le menu Tools, choisissez Options.

- Dans la boîte de dialogue Options, ouvrez le noeud Debugging, puis choisissez General.

- Activez ou désactivez l'option Enable Just My Code.

II-B - DebuggerHiddenAttribute

Cet attribut permet de masquer des morceaux de code au debugger. Le fait de l'appliquer à une méthode par exemple va rendre impossible l'ajout d'un point d'arrêt sur cette méthode, et il ne sera pas possible de " passer dans cette méthode " avec le debugger. Cet attribut vous offre la possibilité d'empêcher un développeur de debugger un morceau de code qui ne le justifie pas.

Attention, il faut utiliser cet attribut avec parcimonie et sur du code déjà testé car il peut devenir un vrai casse-tête si un bug se trouve dans une classe dont un membre couvert par cet attribut. Heureusement la méthode apparaîtra dans la Call-Stack.

Reprenons la classe Developer, nous allons taguer la méthode GetSeniority() avec l'attribut DebuggerHidden.

Classe Developer avec DebuggerStepThroughAttribute

public class Developer
{
[DebuggerDisplay("{FirstName} joined the company in {Year}")]
public Int16 Year { get; set; }
public String FirstName { get; set; }
public String Name { get; set; }

[DebuggerBrowsable(DebuggerBrowsableState.Collapsed)]
public List<String> Skills { get; set; }

public Developer(string firstname, string name, Int16 year)
{
this.FirstName = firstname;
this.Name = name;
this.Year = year;
this.Skills = new List<string>();
}

[DebuggerStepThrough()]
public Int32 GetSeniority()
{
return DateTime.Now.Year - this.Year;
}
}

II-C - DebuggerStepThroughAttribute

Cet attribut est quasiment identique au précédent (DebuggerHidden) en effet il indique au debugger qu'il ne doit pas entrer dans le corps du membre sur lequel il est apposé. Cependant à la différence de DebuggerHidden il est possible de poser un point d'arrêt dans du code marqué par l'attribut DebuggerStepThrough.

DebuggerStepThroughAttribute

Cet attribut peut s'avérer utile lorsqu'il s'agit de débugger du code qui fait appel à de très nombreuses propriétés ou constantes et l'on souhaite éviter de faire chauffer sa touche F11 pour passer au travers de quelques lignes de code seulement !

II-D - DebuggerNonUserCodeAttribute

Cet attribut a le même effet que DebuggerHidden et DebuggerStepThrough combinés. Le debugger ne tiendra pas compte de ce code si l'option " Just My Code " est activée sinon il sera normalement debuggable.

III - Conclusion

Il est important de rappeler que tous ces attributs sont à destination du debugger et que la CLR le les interprète pas. Ils peuvent être utiles dans des cas précis et à ce titre ils doivent être connus des développeurs mais il ne faut pas en abuser sous peine de pendre un temps précieux lors du débogage alors que leur rôle premier est d'en faire gagner !

IV - Ressources

Liens vers le MSDN

DebuggerBrowsableAttribute Class
DebuggerDisplayAttribute Class

Liens vers Developpez.com

Mes articles
Mon blog
Les articles des autres rédacteurs
La rubrique .Net de Developpez.com