Utilisation de l'attribut DebuggerDisplay

Mise à jour : novembre 2007

Cette rubrique s'applique à :

Édition	Visual Basic	C#	C++	Web Developer
Express
Standard
Pro et Team

Légende du tableau :

	Applicable
	Non applicable
	Commande ou commandes masquées par défaut.

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.

En code C#, vous pouvez utiliser une expression générale entre accolades. L'expression a un accès implicite au pointeur this, uniquement pour l'instance actuelle du type cible. 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.

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 Debugging, 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.

Attribut	Sortie (affichée dans la colonne Valeur)
[DebuggerDisplay("x = {x} y = {y}")] Utilisé sur un type avec champs x et y.	x = 5 y = 18
[DebuggerDisplay("String value is {getString()}")] La syntaxe des paramètres peut varier d'un langage à l'autre. Par conséquent, soyez vigilant dans son emploi.	String value is [5, 6, 6]
[DebuggerDisplay("Object {count - 2}: {(flag) ? \"yes\" : \"no\"}")] La syntaxe des expressions varie d'un langage à l'autre. Par conséquent, soyez vigilant dans son emploi.	Object 6: yes
[DebuggerDisplay("Last = {_lastName,nq} {_var == null ? \"\" : \"First = \" + _firstName,nq}")] ,nq supprime les guillemets.	Si le nom est présent Last = lastname First = firstname sinon : Last = lastname

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

Paramètres	But
Name, Type	Ces paramètres affectent les colonnes Nom et Type des fenêtres de variables. (Ils peuvent recevoir la valeur des chaînes utilisant la même syntaxe que le constructeur.) L'abus de ces paramètres (ou une utilisation incorrecte) peut donner un résultat confus.
Target, TargetTypeName	Spécifie le type cible lorsque l'attribut est utilisé au niveau de l'assembly.

Remarque :

Le fichier autoexp.cs utilise l'attribut DebuggerDisplay au niveau de l'assembly. Le fichier autoexp.cs détermine les expansions par défaut utilisées par Visual Studio pour les variables C#. Vous pouvez examiner le fichier autoexp.cs pour des exemples d'utilisation de l'attribut DebuggerDisplay ou modifier et compiler le fichier autoexp.cs pour changer les expansions par défaut. Assurez-vous d'avoir sauvegardé le fichier autoexp.cs avant de le modifier. Vous devez ajouter une référence au fichier Microsoft.VisualStudio.DebuggerVisualizers.dll dans \Program Files\Microsoft Visual Studio 9.0\Common7\IDE\PublicAssemblies. Le fichier autoexp.cs se trouve dans Mes documents/Visual Studio 9.0/Visualizers.

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 :

Nom	Valeur	Type
Key	"three"	objet {string}
Value	3	objet {int}

[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("Count = {hashtable.Count}")]
[DebuggerTypeProxy(typeof(HashtableDebugView))]
class MyHashtable
{
    public Hashtable hashtable;

    public MyHashtable()
    {
        hashtable = new Hashtable();  
    }

    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

Concepts

Affichage des types de données personnalisés

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

Référence

Utilisation de l'attribut DebuggerTypeProxy