Verbessern des Debuggens mit den Debuggeranzeigeattributen
Hinweis
Dieser Artikel gilt für das .NET Framework. Er 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 dessen Laufzeitverhalten angibt und am besten versteht, ebenfalls anzugeben, wie der Typ aussieht, wenn er in einem Debugger angezeigt wird. Zusätzlich können Debuggeranzeigeattribute, die eine Target-Eigenschaft bereitstellen, von den Benutzern auf Assemblyebene angewendet werden, ohne dass diese den Quellcode kennen müssen. Das DebuggerDisplayAttribute-Attribut steuert die Anzeige eines Typs oder Members in den Variablenfenstern des Debuggers. Das DebuggerBrowsableAttribute-Attribut bestimmt, ob und wie ein Feld oder eine Eigenschaft in den Variablenfenstern des Debuggers angezeigt wird. Das DebuggerTypeProxyAttribute-Attribut gibt einen Ersatztyp oder einen Proxy für einen Typ an und ändert die Art, wie dieser Typ in Debuggerfenstern angezeigt wird. Wenn Sie eine Variable mit einem Proxy oder einem Ersatztyp anzeigen, wird der Proxy stellvertretend für den ursprünglichen Typ im Anzeigefenster des Debuggers angezeigt . Im Debuggervariablenfenster werden nur die öffentlichen Member des Proxytyps angezeigt. Private Member werden nicht angezeigt.
Verwenden des DebuggerDisplayAttribute-Konstruktors
Der DebuggerDisplayAttribute-Konstruktor verfügt über ein einziges Argument: Eine Zeichenfolge, die in der Wertspalte für Instanzen des Typs angezeigt wird. Diese Zeichenfolge kann geschweifte Klammern ({ und }) enthalten. Der Text innerhalb von Klammern wird als Ausdruck ausgewertet. Beispielsweise verursacht der folgende C#-Code, dass „Count = 4“ angezeigt wird, wenn das Pluszeichen (+) angeklickt wird, um die Debuggeranzeige für eine Instanz von MyHashtable anzuzeigen.
[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 zugelassen, der nur über impliziten Zugriff auf diesen Verweis auf die aktuelle Instanz des Zieltyps verfügt. Der Ausdruck ist begrenzt, er hat 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 bei einem C#-Objekt beispielsweise ToString() überschrieben wurde, ruft der Debugger die Überschreibung auf und zeigt deren Ergebnisse anstelle des standardmäßigen {<typeName>}. an. Wenn Sie also ToString() überschrieben haben, müssen Sie DebuggerDisplayAttribute nicht verwenden. Wenn Sie beides verwenden, hat das DebuggerDisplayAttribute-Attribut Vorrang gegenüber der ToString()-Überschreibung.
Verwenden von DebuggerBrowsableAttribute
Wenden Sie DebuggerBrowsableAttribute 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 nimmt einen der DebuggerBrowsableState-Enumerationswerte an, die einen der folgenden Zustände angeben:
Never gibt an, dass das Element nicht im Datenfenster angezeigt wird. Verwenden Sie diesen Wert beispielsweise für den DebuggerBrowsableAttribute eines Felds, um das Feld aus der Hierarchie zu entfernen. Das Feld wird nicht angezeigt, wenn Sie den einschließenden Typ erweitern, indem Sie auf das Pluszeichen (+) für die Typinstanz 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. Seine enthaltenen Objekte werden jedoch angezeigt, wenn es sich bei diesen um Arrays oder Sammlungen handelt.
Hinweis
Das DebuggerBrowsableAttribute wird von Visual Basic in .NET Framework-Version 2.0 nicht unterstützt.
Das folgende Codebeispiel veranschaulicht die Verwendung von DebuggerBrowsableAttribute, um zu verhindern, dass die ihm folgende Eigenschaft im Debugfenster für die Klasse angezeigt wird.
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
public static string y = "Test String";
Verwenden von DebuggerTypeProxy
Verwenden Sie das DebuggerTypeProxyAttribute-Attribut, wenn Sie die Debuggingansicht eines Typs erheblich und grundlegend ändern müssen, ohne den Typ selbst zu ändern. Das DebuggerTypeProxyAttribute-Attribut wird verwendet, um einen Anzeigeproxy für einen Typ anzugeben. Dadurch wird es einem Entwickler ermöglicht, die Ansicht des Typs anzupassen. Dieses Attribut kann genau wie DebuggerDisplayAttribute auf Assemblyebene verwendet werden. In diesem Fall gibt die Target-Eigenschaft den Typ an, für den der Proxy verwendet wird. Es wird empfohlen, dass das Attribut einen privaten geschachtelten Typ angibt, der innerhalb des Typs auftritt, auf den das Attribut angewendet wird. Eine Ausdrucksauswertung, die Überprüfungen für die Ansichten von Typen für dieses Attribut unterstützt, 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, werden im Debuggervariablenfenster nur die öffentlichen Member des Proxytyps angezeigt. Private Member werden nicht angezeigt. Das Verhalten des Datenfensters wird durch von Attributen erweiterte Ansichten nicht verändert.
Um unnötige Leistungseinbußen zu vermeiden, werden Attribute des Anzeigeproxys nicht verarbeitet, bis das Objekt erweitert wurde. Dies geschieht entweder, indem der Benutzer auf das Pluszeichen (+) neben dem Typ im Datenfenster klickt, oder durch Anwenden des DebuggerBrowsableAttribute-Attributs. Aus diesem Grund wird empfohlen, keine Attribute auf den Anzeigetyp anzuwenden. Attribute können und sollen im Text des Anzeigetyps 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 der Attribute DebuggerDisplayAttribute, DebuggerBrowsableAttribute und DebuggerTypeProxyAttribute zu sehen.
Code
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
