Verbesserung des Debuggings mit den Debuggeranzeige-Attributen

Hinweis

Dieser Artikel ist spezifisch für .NET Framework. Sie gilt nicht für neuere Implementierungen von .NET, einschließlich .NET 6 und höherer Versionen.

Debuggeranzeigeattribute ermöglichen es dem Entwickler des Typs, der das Laufzeitverhalten dieses Typs angibt und am besten versteht, auch anzugeben, wie dieser Typ aussieht, wenn er in einem Debugger angezeigt wird. Darüber hinaus können Debuggeranzeigeattribute, die eine Target Eigenschaft bereitstellen, von Benutzern ohne Kenntnisse des Quellcodes auf Assemblyebene angewendet werden. Das DebuggerDisplayAttribute Attribut steuert, wie ein Typ oder Element in den Fenstern der Debuggervariablen angezeigt wird. Das DebuggerBrowsableAttribute Attribut bestimmt, ob und wie ein Feld oder eine Eigenschaft in den Fenstern der Debuggervariablen angezeigt wird. Das DebuggerTypeProxyAttribute Attribut gibt einen Ersatztyp oder einen Proxy für einen Typ an und ändert die Art der Anzeige des Typs in Debuggerfenstern. Wenn Sie eine Variable mit einem Proxy- oder Ersatztyp anzeigen, ersetzt der Proxy den ursprünglichen Typ im Debugger-Darstellungsfenster. Im Debuggervariablenfenster werden nur die öffentlichen Member des Proxytyps angezeigt. Private Mitglieder werden nicht angezeigt.

Verwenden des DebuggerDisplay-Attributs

Der DebuggerDisplayAttribute Konstruktor weist ein einzelnes Argument auf: eine Zeichenfolge, die in der Wertspalte für Instanzen des Typs angezeigt werden soll. Diese Zeichenfolge kann geschweifte Klammern ({ und }) enthalten. Der Text innerhalb von Klammern wird als Ausdruck ausgewertet. Der folgende C#-Code bewirkt beispielsweise, dass "Count = 4" angezeigt wird, wenn das Pluszeichen (+) ausgewählt ist, um die Debuggeranzeige für eine Instanz von MyHashtablezu erweitern.

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

Attribute, die auf Eigenschaften angewendet werden, auf die im Ausdruck verwiesen wird, werden nicht verarbeitet. Für den C#-Compiler ist ein allgemeiner Ausdruck zulässig, der nur impliziten Zugriff auf diesen Verweis für die aktuelle Instanz des Zieltyps hat. Der Ausdruck ist begrenzt; Es gibt keinen Zugriff auf Aliase, lokale Variablen oder Zeiger. In C#-Code können Sie einen allgemeinen Ausdruck zwischen den Klammern verwenden, der nur über impliziten Zugriff auf den this-Zeiger für die aktuelle Instanz des Zieltyps verfügt.

Wenn ein C#-Objekt eine Überschreibung von ToString() aufweist, ruft der Debugger diese auf und zeigt das Ergebnis anstelle des Standard-{<typeName>}. an. Wenn Sie ToString() überschrieben haben, brauchen Sie DebuggerDisplayAttribute nicht zu verwenden. Wenn Sie beides verwenden, hat das DebuggerDisplayAttribute Attribut Vorrang vor der ToString() Überschreibung.

Verwenden von DebuggerBrowsableAttribute

Wenden Sie das DebuggerBrowsableAttribute Feld oder die Eigenschaft auf ein Feld oder eine Eigenschaft an, um anzugeben, wie das Feld oder die Eigenschaft im Debuggerfenster angezeigt werden soll. Der Konstruktor für dieses Attribut akzeptiert einen der DebuggerBrowsableState Enumerationswerte, der einen der folgenden Zustände angibt:

• Never gibt an, dass das Element nicht im Datenfenster angezeigt wird. Wenn Sie z. B. diesen Wert für das DebuggerBrowsableAttribute Feld in einem Feld verwenden, wird das Feld aus der Hierarchie entfernt. Das Feld wird nicht angezeigt, wenn Sie den umschließenden Typ erweitern, indem Sie für die Typinstanz auf das Pluszeichen (+) klicken.

• Collapsed gibt an, dass das Element angezeigt, aber nicht standardmäßig erweitert wird. Dies ist das Standardverhalten.

• RootHidden gibt an, dass das Element selbst nicht angezeigt wird, dessen Bestandteilobjekte jedoch angezeigt werden, wenn es sich um ein Array oder eine Auflistung handelt.

Hinweis

Dies DebuggerBrowsableAttribute wird von Visual Basic in .NET Framework, Version 2.0, nicht unterstützt.

Das folgende Codebeispiel zeigt die Verwendung von DebuggerBrowsableAttribute, um zu verhindern, dass die darauf folgende Eigenschaft im Debugfenster für die Klasse angezeigt wird.

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

Verwenden des DebuggerTypeProxy

Verwenden Sie das DebuggerTypeProxyAttribute Attribut, wenn Sie die Debugansicht eines Typs erheblich ändern und grundlegend ändern müssen, aber nicht den Typ selbst. Das DebuggerTypeProxyAttribute Attribut wird verwendet, um einen Anzeigeproxy für einen Typ anzugeben, sodass ein Entwickler die Ansicht für den Typ anpassen kann. Dieses Attribut kann wie das DebuggerDisplayAttributeauf Assemblyebene verwendet werden. In diesem Fall gibt die Target Eigenschaft den Typ an, für den der Proxy verwendet wird. Die empfohlene Verwendung besteht darin, dass dieses Attribut einen privaten geschachtelten Typ angibt, der innerhalb des Typs auftritt, auf den das Attribut angewendet wird. Ein Ausdrucksauswerter, der Typanzeigen unterstützt, sucht nach diesem Attribut, wenn ein Typ angezeigt wird. Wenn das Attribut gefunden wird, ersetzt die Ausdrucksauswertung den Anzeigeproxytyp für den Typ, auf den das Attribut angewendet wird.

Wenn DebuggerTypeProxyAttribute vorhanden ist, zeigt das Debugger-Variablenfenster nur die öffentlichen Mitglieder des Proxytyps an. Private Mitglieder werden nicht angezeigt. Das Verhalten des Datenfensters wird durch Attribut-erweiterte Ansichten nicht geändert.

Um unnötige Leistungseinbußen zu vermeiden, werden Attribute des Anzeigeproxys erst verarbeitet, wenn das Objekt erweitert wird, entweder durch Klicken auf das Pluszeichen (+) neben dem Typ in einem Datenfenster oder durch die Anwendung des DebuggerBrowsableAttribute Attributs. Daher wird empfohlen, keine Attribute auf den Anzeigetyp anzuwenden. Attribute können und sollten innerhalb des Inhalts des Darstellungstyps angewendet werden.

Das folgende Codebeispiel veranschaulicht die Verwendung von DebuggerTypeProxyAttribute, um einen Typ anzugeben, der als Debuggeranzeigeproxy verwendet werden soll.

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

Beispiel

BESCHREIBUNG

Das folgende Codebeispiel kann in Visual Studio angezeigt werden, um die Ergebnisse der Anwendung von DebuggerDisplayAttribute, DebuggerBrowsableAttributeund DebuggerTypeProxyAttribute Attributen anzuzeigen.

Programmcode

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

Siehe auch

• DebuggerDisplayAttribute
• DebuggerBrowsableAttribute
• DebuggerTypeProxyAttribute