Utilisation de l'attribut DebuggerDisplay

L'attribut DebuggerDisplay (System.Diagnostics.DebuggerDisplayAttribute) contrôle la façon dont une classe ou un champ s'affiche dans les fenêtres de variables du débogueur. Cet attribut peut s'appliquer aux éléments suivants :

• Classes

• Structures

• Délégués

• Enums

• Champs

• Propriétés

• Assemblys

L'attribut DebuggerDisplay possède un seul argument, qui est une chaîne à afficher dans la colonne valeur des instances du type. Cette chaîne peut contenir des accolades ({ et }). Le texte entre deux accolades sera évalué comme un champ, une propriété ou une méthode.

Si un objet C# a un ToString() substitué, le débogueur appelle la substitution et affiche son résultat au lieu du {<typeName>} standard. Par conséquent, si vous avez remplacé ToString(), vous n'avez pas besoin d'utiliser DebuggerDisplay. Si vous utilisez les deux, l'attribut DebuggerDisplay prend la priorité sur la substitution de ToString().

L'évaluation par le débogueur de cet appel ToString() implicite dépend d'un paramètre utilisateur dans la boîte de dialogue Options (catégorie Débogage, page Général). Visual Basic n'implémente pas cette évaluation ToString() implicite.

Le tableau suivant montre quelques-unes des utilisations possibles de l'attribut DebuggerDisplay et quelques exemples de sorties.

DebuggerDisplay peut également accepter des paramètres nommés.

Utilisation d'expressions dans DebuggerDisplay

Bien que vous puissiez utiliser une expression générale à l'intérieur de l'accolade dans un attribut DebuggerDisplay, cette méthode n'est pas recommandée.

Une expression générale DebuggerDisplay dispose d'un accès implicite au pointeur this pour l'instance actuelle du type de cible uniquement. L'expression n'a accès ni aux alias, ni aux variables locales, ni aux pointeurs. Si l'expression référence des propriétés, les attributs de ces propriétés ne sont pas traités. Par exemple, le code C# [DebuggerDisplay("Object {count - 2}" afficherait Object 6 si le champ count avait la valeur 8.

L'utilisation d'expressions dans DebuggerDisplay peut provoquer les problèmes suivants :

• L'évaluation des expressions est l'opération la plus coûteuse dans le débogueur et l'expression est évaluée chaque fois qu'elle est affichée. Cela peut provoquer des problèmes de performances pendant l'exécution du code pas à pas. Par exemple, une expression complexe qui est utilisée pour afficher des valeurs dans une collection ou une liste peut être très lente lorsque le nombre d'éléments est important.

• Les expressions sont évaluées par l'évaluateur d'expression du langage du cadre de pile actuel et pas par l'évaluateur du langage dans lequel l'expression a été écrite. Cela peut provoquer des résultats inattendus lorsque les langages sont différents.

• L'évaluation d'une expression peut modifier l'état de l'application. Par exemple, une expression qui définit la valeur d'une propriété transforme la valeur d'une propriété dans le code en cours de exécution.

Une façon de réduire les problèmes potentiels de l'évaluation de l'expression consiste à créer une propriété privée qui exécute l'opération et retourne une chaîne. L'attribut DebuggerDisplay peut ensuite afficher la valeur de cette propriété privée. L'exemple suivant implémente ce modèle :

[DebuggerDisplay("{DebuggerDisplay,nq}")]public sealed class MyClass {    public int count { get; set; }    public bool flag { get; set; }    private string DebuggerDisplay {        get{ return string.Format("("Object {0}", count - 2); }    }}

Exemple

L'exemple de code suivant explique l'utilisation de DebuggerDisplay, ainsi que de DebuggerBrowseable et DebuggerTypeProxy. Lorsqu'il s'affiche dans une fenêtre de variables du débogueur, comme la fenêtre Espion, il produit une expansion de ce genre :

[DebuggerDisplay("{value}", Name = "{key}")]
internal class KeyValuePairs
{
    private IDictionary dictionary;
    private object key;
    private object value;
    public KeyValuePairs(IDictionary dictionary, object key, object value)
    {
        this.value = value;
        this.key = key;
        this.dictionary = dictionary;
    }

    public object Key
    {
        get { return key; }
        set
        {
            object tempValue = dictionary[key];
            dictionary.Remove(key);
            key = value;
            dictionary.Add(key, tempValue);
        }
    }

    public object Value
    {
        get { return this.value; }
        set
        {
            this.value = value;
            dictionary[key] = this.value;
        }
    }
}

[DebuggerDisplay("{DebuggerDisplay,nq}")]
[DebuggerTypeProxy(typeof(HashtableDebugView))]
class MyHashtable
{
    public Hashtable hashtable;

    public MyHashtable()
    {
        hashtable = new Hashtable();  
    }    private string DebuggerDisplay    {        get { return "Count = " + hashtable.Count); }    }

    private class HashtableDebugView
    {
        private MyHashtable myhashtable;
        public HashtableDebugView(MyHashtable myhashtable)
        {
            this.myhashtable = myhashtable;
        }

        [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
        public KeyValuePairs[] Keys
        {
            get
            {
                KeyValuePairs[] keys = new KeyValuePairs[myhashtable.hashtable.Count];

                int i = 0;
                foreach (object key in myhashtable.hashtable.Keys)
                {
                    keys[i] = new KeyValuePairs(myhashtable.hashtable, key, myhashtable.hashtable[key]);
                    i++;
                }
                return keys;
            }
        }
    }
}

Voir aussi

Référence

Utilisation de l'attribut DebuggerTypeProxy

Concepts

Affichage des types de données personnalisés

Amélioration du débogage avec les attributs d'affichage de débogueur