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
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
Sélectionnez

    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
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
Sélectionnez

    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é
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
N'affiche pas l'élément



Avec DebuggerBrowsable à Never

Affiche l'élément réduit
Affiche l'élément réduit



Avec DebuggerBrowsable à Never

N'affiche pas l'élément racine
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
Sélectionnez

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