.Net : Utilisation des attributs de débogage

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 :

    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 :

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

    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.

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

Avec DebuggerBrowsable à Never

Avec DebuggerBrowsable à Never

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

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.

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

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.

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

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.

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 !

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.