Verbessern des Debuggens mit den Debuggeranzeigeattributen
Debuggeranzeigeattribute ermöglichen es einem Entwickler eines Typs, der das Laufzeitverhalten dieses Typs festlegt und am besten damit vertraut ist, auch anzugeben, wie dieser Typ in einem Debugger angezeigt wird. Außerdem können Debuggeranzeigeattribute, die die Target-Eigenschaft bereitstellen, von Benutzern, die den Quellcode nicht kennen, auf der Assemblyebene angewendet werden. Das DebuggerDisplayAttribute-Attribut steuert die Anzeige eines Typs oder eines Members in den Debuggervariablenfenstern. Das DebuggerBrowsableAttribute-Attribut bestimmt, ob und wie ein Feld oder eine Eigenschaft in den Debuggervariablenfenstern angezeigt wird. Das DebuggerTypeProxyAttribute-Attribut gibt einen Ersatztyp (einen Proxy) für einen Typ an und ändert die Art, in der der Typ in Debuggerfenstern angezeigt wird. Wenn Sie eine Variable mit einem Proxy (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 von DebuggerDisplayAttribute
Der DebuggerDisplayAttribute-Konstruktor verfügt über ein einzelnes Argument: eine Zeichenfolge, die in der Spalte Wert für Instanzen des Typs angezeigt wird. Diese Zeichenfolge kann geschweifte Klammern ({ und }) enthalten. Der Text innerhalb eines Paares geschweifter Klammern wird als Ausdruck ausgewertet. So wird beispielsweise mit dem folgenden C#-Code "Count = 4" angezeigt, wenn das Pluszeichen (+) ausgewählt wird, um eine Instanz von MyHashtable in der Debuggeranzeige zu erweitern.
[DebuggerDisplay("Count = {count}")]
class MyHashtable
{
public int count = 4;
}
Es werden keine Attribute verarbeitet, die auf Eigenschaften angewendet werden, auf die im Ausdruck verwiesen wird. Für den C#-Compiler ist ein allgemeiner Ausdruck zulässig, der nur über impliziten Zugriff auf diesen Verweis für die aktuelle Instanz des Zieltyps verfügt. Der Ausdruck ist eingeschränkt. Der Zugriff auf Aliase, lokale Variablen oder Zeiger ist nicht möglich. In C#-Code können Sie in den geschweiften Klammern einen allgemeinen Ausdruck verwenden, der lediglich über impliziten Zugriff auf den this-Zeiger für die aktuelle Instanz des Zieltyps verfügt.
Falls beispielsweise ein überschriebenes ToString() für ein C#-Objekt vorhanden ist, ruft der Debugger die Überschreibung auf und zeigt deren Ergebnis anstelle des standardmäßigen {<typeName>}. an. Auf diese Weise müssen Sie nicht DebuggerDisplayAttribute verwenden, falls Sie ToString() überschrieben haben. Wenn Sie beides verwenden, hat das DebuggerDisplayAttribute-Attribut Vorrang gegenüber der ToString()-Überschreibung.
Verwenden von DebuggerBrowsableAttribute
Wenden Sie das DebuggerBrowsableAttribute auf ein Feld oder eine Eigenschaft an, um anzugeben, wie das Feld oder die Eigenschaft im Debuggerfenster angezeigt wird. Der Konstruktor für dieses Attribut akzeptiert einen der DebuggerBrowsableState-Enumerationswerte, der einen der folgenden Zustände angibt:
Never gibt an, dass der Member nicht im Datenfenster angezeigt wird. Bei Verwendung dieses Werts für das DebuggerBrowsableAttribute eines Felds wird beispielsweise das Feld aus der Hierarchie entfernt. Das Feld wird nicht angezeigt, wenn Sie den einschließenden Typ durch Klicken auf das Pluszeichen (+) für die Typeninstanz erweitern.
Collapsed gibt an, dass der Member angezeigt, aber nicht standardmäßig erweitert wird. Dies ist das Standardverhalten.
RootHidden gibt an, dass der Member selbst nicht angezeigt wird. Wenn es sich um ein Array oder eine Auflistung handelt, werden jedoch die konstituierenden Objekte angezeigt.
.gif "Hinweis") Hinweis |
|---|
Das DebuggerBrowsableAttribute wird von Visual Basic in .NET Framework, Version 2.0, nicht unterstützt. |
Im folgenden Codebeispiel wird veranschaulicht, wie das DebuggerBrowsableAttribute verwendet wird, damit die nachfolgende Eigenschaft für die Klasse nicht im Debuggerfenster angezeigt wird.
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
public static string y = "Test String";
Verwenden von DebuggerTypeProxy
Verwenden Sie das DebuggerTypeProxyAttribute-Attribut, wenn Sie die Debuggeransicht eines Typs, nicht jedoch den Typ selbst, grundlegend ändern müssen. Das DebuggerTypeProxyAttribute-Attribut wird verwendet, um einen Anzeigeproxy für einen Typ anzugeben, damit die Ansicht des Typs bei der Entwicklung angepasst werden kann. Wie auch DebuggerDisplayAttribute kann dieses Attribut auf der Assemblyebene verwendet werden. In diesem Fall legt die Target-Eigenschaft den Typ fest, für den der Proxy verwendet wird. Es wird empfohlen, dass mit diesem Attribut ein privater geschachtelter Typ angegeben wird, der innerhalb des Typs vorhanden ist, auf den das Attribut angewendet wird. Eine Ausdrucksauswertung, die beim Anzeigen eines Typs das Überprüfen von Typ-Viewern unterstützt. Wenn das Attribut gefunden wird, ersetzt die Ausdrucksauswertung den Anzeigeproxytyp für den Typ, auf den das Attribut angewendet wird.
Wenn das DebuggerTypeProxyAttribute vorhanden ist, werden im Variablenfenster des Debuggers nur die öffentlichen Member des Proxytyps angezeigt. Private Member werden nicht angezeigt. Das Verhalten des Datenfensters ändert sich nicht, wenn Ansichten durch Attribute modifiziert werden.
Um unnötige Leistungseinbußen zu vermeiden, werden die Attribute des Ansichtsproxys erst verarbeitet, wenn das Objekt erweitert wird, entweder durch Klicken auf das Pluszeichen (+) neben dem Typ im Datenfenster oder durch Anwendung des DebuggerBrowsableAttribute-Attributs. Deshalb wird empfohlen, keine Attribute auf den Anzeigetyp anzuwenden. Attribute können und sollen im Text des Anzeigetyps angewendet werden.
Im folgenden Codebeispiel wird veranschaulicht, wie DebuggerTypeProxyAttribute verwendet wird, um einen Typ als Debuggeranzeigeproxy anzugeben.
[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 2005 angezeigt werden. Sie sehen dann die jeweiligen Auswirkungen, wenn die Attribute DebuggerDisplayAttribute, DebuggerBrowsableAttribute und DebuggerTypeProxyAttribute angewendet werden.
Code
Imports System
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 'Main
End Class 'DebugViewTest
<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 'New
End Class 'KeyValuePairs
<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 'New
<DebuggerBrowsable(DebuggerBrowsableState.RootHidden)> _
ReadOnly Property Keys as KeyValuePairs()
Get
Dim nkeys(hashtable.Count) 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 'HashtableDebugView
End Class 'MyHashtable
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;
}
}
}
}
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();
}