Compartir a través de

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

Nota:

Este artículo es específico de .NET Framework. No se aplica a implementaciones más recientes de .NET, incluidas .NET 6 y versiones posteriores.

Los atributos de visualización del depurador permiten al desarrollador del tipo, que especifica y comprende mejor el comportamiento en tiempo de ejecución de ese tipo, especificar también cómo se verá ese tipo cuando se muestre en un depurador. Además, los atributos de visualización del depurador que proporcionan una Target propiedad pueden ser aplicados por los usuarios al nivel de ensamblado sin tener conocimiento del código fuente. El DebuggerDisplayAttribute atributo controla cómo se muestra un tipo o miembro en las ventanas de variables del depurador. El DebuggerBrowsableAttribute atributo determina si se muestra un campo o una propiedad en las ventanas de variables del depurador. El DebuggerTypeProxyAttribute atributo especifica un tipo sustituto, o un proxy, para un tipo y cambia la forma en que se muestra el tipo en las ventanas del depurador. Cuando se ve una variable que tiene un proxy, o un tipo sustitutivo, el proxy reemplaza al tipo original en la ventana de presentación del depurador. En la ventana de las variables del depurador se muestran sólo los miembros públicos del tipo de servidor proxy. No se muestran los miembros privados.

Uso de DebuggerDisplayAttribute

El DebuggerDisplayAttribute constructor tiene un único argumento: 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 encerrado entre llaves se evalúa como una expresión. Por ejemplo, el siguiente código de C# hace que se muestre "Count = 4" cuando se selecciona el signo más (+) para expandir la presentación del depurador para una instancia de MyHashtable.

[DebuggerDisplay("Count = {count}")]
class MyHashtable
{
    public int count = 4;
}

Los atributos aplicados a las propiedades a las que se hace referencia en la expresión no se procesan. Para el compilador de C#, se permite una expresión general que solo tiene acceso implícito a esta referencia para la instancia actual del tipo de destino. La expresión es limitada; no hay acceso a alias, variables locales o punteros. En el código de C#, puede usar una expresión general entre las llaves que tenga acceso implícito al puntero this solo para la instancia actual del tipo de destino.

Por ejemplo, si un objeto de C# tiene un ToString() invalidado, el depurador llamará a la invalidación y mostrará su resultado en lugar del {<typeName>}. estándar. Por lo tanto, si ha invalidado ToString(), no necesita usar DebuggerDisplayAttribute. Si utiliza ambos, el atributo DebuggerDisplayAttribute tiene prioridad sobre el reemplazo de ToString().

Uso del atributo DebuggerBrowsableAttribute

Aplique DebuggerBrowsableAttribute a un campo o propiedad para especificar cómo se va a mostrar el campo o la propiedad en la ventana del depurador. El constructor de este atributo toma uno de los DebuggerBrowsableState valores de enumeración, que especifica uno de los estados siguientes:

  • Never indica que el miembro no se muestra en la ventana de datos. Por ejemplo, con este valor para DebuggerBrowsableAttribute en un campo se quita el campo de la jerarquía; el campo no se muestra cuando expande el tipo envolvente haciendo clic en el signo más (+) para la instancia del tipo.

  • Collapsed indica que el miembro se muestra pero no se expande de forma predeterminada. Este es el comportamiento predeterminado.

  • RootHidden indica que el propio miembro no se muestra, pero sus objetos constituyentes se muestran si es una matriz o colección.

Nota:

DebuggerBrowsableAttribute no es compatible con Visual Basic en la versión 2.0 de .NET Framework.

En el ejemplo de código siguiente se muestra el uso de DebuggerBrowsableAttribute para evitar que la propiedad que le sigue aparezca en la ventana de depuración de la clase.

[DebuggerBrowsable(DebuggerBrowsableState.Never)]
public static string y = "Test String";

Uso de DebuggerTypeProxy

Use el DebuggerTypeProxyAttribute atributo cuando necesite cambiar significativamente y fundamentalmente la vista de depuración de un tipo, pero no cambiar el propio tipo. El DebuggerTypeProxyAttribute atributo se usa para especificar un proxy de visualización para un tipo, lo que permite a un desarrollador adaptar la vista del tipo. Este atributo, como , DebuggerDisplayAttributese puede usar en el nivel de ensamblado, en cuyo caso la Target propiedad especifica el tipo para el que se usará el proxy. El uso recomendado es que este atributo especifica un tipo anidado privado que se produce dentro del tipo al que se aplica el atributo. Un evaluador de expresiones que admite visores de tipos comprueba este atributo cuando se muestra un tipo. Si se encuentra el atributo, el evaluador de expresiones sustituye el tipo de proxy de visualización por el tipo al que se aplica el atributo.

Cuando está presente DebuggerTypeProxyAttribute, en la ventana de las variables del depurador se muestran solo los miembros públicos del tipo de servidor proxy. No se muestran los miembros privados. Las vistas mejoradas por atributos no cambian el comportamiento de la ventana de datos.

Para evitar disminuciones innecesarias del rendimiento, los atributos del servidor proxy de presentación no se procesan hasta que el objeto esté expandido, ya sea a través del usuario que hace clic en el signo más (+) situado junto al tipo en una ventana de datos o a través de la aplicación del atributo DebuggerBrowsableAttribute. Por lo tanto, se recomienda que no se aplique ningún atributo al tipo de presentación. Los atributos pueden y deben aplicarse dentro del cuerpo del tipo de presentación.

En el ejemplo de código siguiente se muestra el uso de DebuggerTypeProxyAttribute para especificar un tipo que se usará como proxy de visualización del depurador.

[DebuggerTypeProxy(typeof(HashtableDebugView))]
class MyHashtable : Hashtable
{
    private const string TestString =
        "This should not appear in the debug window.";

    internal class HashtableDebugView
    {
        private Hashtable hashtable;
        public const string TestStringProxy =
            "This should appear in the debug window.";

        // The constructor for the type proxy class must have a
        // constructor that takes the target type as a parameter.
        public HashtableDebugView(Hashtable hashtable)
        {
            this.hashtable = hashtable;
        }
    }
}

Ejemplo

Descripción

El ejemplo de código siguiente se puede ver en Visual Studio para ver los resultados de aplicar los DebuggerDisplayAttribute, DebuggerBrowsableAttribute y DebuggerTypeProxyAttribute atributos.

Código


using namespace System;
using namespace System::Collections;
using namespace System::Diagnostics;
using namespace System::Reflection;

ref class HashtableDebugView;

[DebuggerDisplay("{value}", Name = "{key}")]
ref class KeyValuePairs
{
private:
    IDictionary^ dictionary;
    Object^ key;
    Object^ value;

public:
    KeyValuePairs(IDictionary^ dictionary, Object^ key, Object^ value)
    {
        this->value = value;
        this->key = key;
        this->dictionary = dictionary;
    }
};

[DebuggerDisplay("Count = {Count}")]
[DebuggerTypeProxy(HashtableDebugView::typeid)]
ref class MyHashtable : Hashtable
{
private:
    static const String^ TestString = "This should not appear in the debug window.";

internal:
    ref class HashtableDebugView
    {
    private:
        Hashtable^ hashtable;
    public:
        static const String^ TestString = "This should appear in the debug window.";
        HashtableDebugView(Hashtable^ hashtable)
        {
            this->hashtable = hashtable;
        }

        [DebuggerBrowsable(DebuggerBrowsableState::RootHidden)]
        property array<KeyValuePairs^>^ Keys
        {
            array<KeyValuePairs^>^ get()
            {
                array<KeyValuePairs^>^ keys = gcnew array<KeyValuePairs^>(hashtable->Count);

                IEnumerator^ ie = hashtable->Keys->GetEnumerator();
                int i = 0;
                Object^ key;
                while (ie->MoveNext())
                {
                    key = ie->Current;
                    keys[i] = gcnew KeyValuePairs(hashtable, key, hashtable[key]);
                    i++;
                }
                return keys;
            }
        }
    };
};

public ref class DebugViewTest
{
private:
    // The following constant will appear in the debug window for DebugViewTest.
    static const String^ TabString = "    ";
public:
    // The following DebuggerBrowsableAttribute prevents the property following it
    // from appearing in the debug window for the class.
    [DebuggerBrowsable(DebuggerBrowsableState::Never)]
    static String^ y = "Test String";

    static void Main()
    {
        MyHashtable^ myHashTable = gcnew MyHashtable();
        myHashTable->Add("one", 1);
        myHashTable->Add("two", 2);
        Console::WriteLine(myHashTable->ToString());
        Console::WriteLine("In Main.");
    }
};

int main()
{
    DebugViewTest::Main();
}

using System;
using System.Collections;
using System.Diagnostics;
using System.Reflection;

class DebugViewTest
{
    // The following constant will appear in the debug window for DebugViewTest.
    const string TabString = "    ";
    // The following DebuggerBrowsableAttribute prevents the property following it
    // from appearing in the debug window for the class.
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    public static string y = "Test String";

    static void Main()
    {
        MyHashtable myHashTable = new MyHashtable();
        myHashTable.Add("one", 1);
        myHashTable.Add("two", 2);
        Console.WriteLine(myHashTable.ToString());
        Console.WriteLine("In Main.");
    }
}
[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;
    }
}
[DebuggerDisplay("Count = {Count}")]
[DebuggerTypeProxy(typeof(HashtableDebugView))]
class MyHashtable : Hashtable
{
    private const string TestString = "This should not appear in the debug window.";

    internal class HashtableDebugView
    {
        private Hashtable hashtable;
        public const string TestString = "This should appear in the debug window.";
        public HashtableDebugView(Hashtable hashtable)
        {
            this.hashtable = hashtable;
        }

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

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

Imports System.Collections
Imports System.Diagnostics
Imports System.Reflection



Class DebugViewTest
    ' The following constant will appear in the debug window for DebugViewTest.
    Const TabString As String = "    "
    ' The following DebuggerBrowsableAttribute prevents the property following it
    ' from appearing in the debug window for the class.
    <DebuggerBrowsable(DebuggerBrowsableState.Never)> _
    Public Shared y As String = "Test String"

    Shared Sub Main()
        Dim myHashTable As New MyHashtable()
        myHashTable.Add("one", 1)
        myHashTable.Add("two", 2)
        Console.WriteLine(myHashTable.ToString())
        Console.WriteLine("In Main.")

    End Sub
End Class
<DebuggerDisplay("{value}", Name:="{key}")> _
Friend Class KeyValuePairs
    Private dictionary As IDictionary
    Private key As Object
    Private value As Object


    Public Sub New(ByVal dictionary As IDictionary, ByVal key As Object, ByVal value As Object)
        Me.value = value
        Me.key = key
        Me.dictionary = dictionary

    End Sub
End Class
<DebuggerDisplay("Count = {Count}"), DebuggerTypeProxy(GetType(MyHashtable.HashtableDebugView))> _
Class MyHashtable
    Inherits Hashtable
    Private Const TestString As String = "This should not appear in the debug window."

    Friend Class HashtableDebugView
        Private hashtable As Hashtable
        Public Shared TestString As String = "This should appear in the debug window."

        Public Sub New(ByVal hashtable As Hashtable)
            Me.hashtable = hashtable
        End Sub

        <DebuggerBrowsable(DebuggerBrowsableState.RootHidden)> _
        ReadOnly Property Keys as KeyValuePairs()
            Get
                Dim nkeys(hashtable.Count - 1) As KeyValuePairs

                Dim i as Integer = 0
                For Each key As Object In hashtable.Keys
                    nkeys(i) = New KeyValuePairs(hashtable, key, hashtable(key))
                    i = i + 1
                Next
                Return nkeys
            End Get
        End Property

    End Class
End Class

Consulte también

  • Last updated on