Utilizar el atributo DebuggerDisplay

Actualización: noviembre 2007

Este tema hace referencia a:

Edición	Visual Basic	C#	C++	Web Developer
Express
Standard
Pro y Team

Leyenda de la tabla:

	Se aplica
	No procede
	Comando o comandos ocultos de forma predeterminada.

El atributo DebuggerDisplay (System.Diagnostics.DebuggerDisplayAttribute) controla la forma en que se muestra una clase o un campo en las ventanas de variables del depurador. Este atributo se puede aplicar a:

• Clases

• Estructuras

• Delegados

• Enumeraciones

• Campos

• Propiedades

• Ensamblados

El atributo DebuggerDisplay tiene un argumento único, que es una cadena que se va a mostrar en la columna de valor para las instancias del tipo. Esta cadena puede contener llaves ({ y }). El texto entre un par de llaves se evaluará como un campo, una propiedad o un método.

En código de C# puede utilizar una expresión general entre las llaves. La expresión tiene acceso implícito al puntero this sólo para la instancia actual del tipo de destino. La expresión no tiene acceso a los alias, variables locales ni punteros. Si la expresión hace referencia a propiedades, no se procesan los atributos en esas propiedades.

Si un objeto de C# tiene un método ToString() invalidado, el depurador llamará al objeto invalidado y mostrará su resultado en lugar del {<typeName>} estándar. Por lo tanto, si ha invalidado ToString(), no tendrá que utilizar DebuggerDisplay. Si utiliza ambos, el atributo DebuggerDisplay tiene prioridad sobre el reemplazo de ToString().

La evaluación de la llamada implícita a ToString() por parte del depurador depende de un valor de configuración del usuario en el cuadro de diálogo Opciones (categoría Depuración, página General). Visual Basic no implementa esta evaluación implícita de ToString().

En la tabla siguiente se muestran algunos posibles usos del atributo DebuggerDisplay y resultados de ejemplo.

Atributo	Resultado que aparece en la columna Valor
[DebuggerDisplay("x = {x} y = {y}")] Se utiliza en un tipo con campos x y y.	x = 5 y = 18
[DebuggerDisplay("String value is {getString()}")] La sintaxis de los parámetros puede variar según el lenguaje. Por consiguiente, utilícela con cuidado.	String value is [5, 6, 6]
[DebuggerDisplay("Object {count - 2}: {(flag) ? \"yes\" : \"no\"}")] La sintaxis de las expresiones varía según el lenguaje. Por consiguiente, utilícela con cuidado.	Object 6: yes
[DebuggerDisplay("Last = {_lastName,nq} {_var == null ? \"\" : \"First = \" + _firstName,nq}")] ,nq quita las comillas.	Si el apellido está presente Last = lastname First = firstname de lo contrario: Last = lastname

DebuggerDisplay también puede aceptar parámetros con nombre.

Parámetros	Finalidad
Name, Type	Estos parámetros afectan a las columnas Nombre y Tipo de las ventanas de variables. (Se pueden establecer en cadenas utilizando la misma sintaxis que el constructor.) El uso excesivo o incorrecto de estos parámetros puede generar resultados confusos.
Target, TargetTypeName	Especifica el tipo de destino cuando se utiliza el atributo en el nivel de ensamblado.

Nota:

El archivo autoexp.cs usa el atributo DebuggerDisplay en el nivel de ensamblado. El archivo autoexp.cs determina las expansiones predeterminadas que Visual Studio utiliza para variables de C#. Puede examinar el archivo autoexp.cs para ver ejemplos de cómo utilizar el atributo DebuggerDisplay, o puede modificar y compilar el archivo autoexp.cs para cambiar las expansiones predeterminadas. Asegúrese de hacer un copia de seguridad del archivo autoexp.cs antes de modificarlo. Debe hacer referencia a Microsoft.VisualStudio.DebuggerVisualizers.dll en \Archivos de programa\Microsoft Visual Studio 9.0\Common7\IDE\PublicAssemblies. Encontrará el archivo autoexp.cs en Mis documentos/Visual Studio 9.0/Visualizers.

Ejemplo

En el ejemplo de código siguiente se muestra cómo utilizar DebuggerDisplay, junto con DebuggerBrowseable y DebuggerTypeProxy. Cuando se ve en una ventana de variables del depurador, como la ventana Inspección, genera una expansión similar a la que sigue:

Nombre	Valor	Tipo
Key	"three"	object {string}
Value	3	object {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;
            }
        }
    }
}

Vea también

Conceptos

Mostrar tipos de datos personalizados

Mejorar la depuración con los atributos de visualización del depurador

Referencia

Utilizar el atributo DebuggerTypeProxy