Dieser Artikel wurde manuell übersetzt. Bewegen Sie den Mauszeiger über die Sätze im Artikel, um den Originaltext anzuzeigen. Weitere Informationen
Übersetzung
Original

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.

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.

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.

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

ms228992.collapse_all(de-de,VS.110).gifBeschreibung

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.

ms228992.collapse_all(de-de,VS.110).gifCode


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


Fanden Sie dies hilfreich?
(1500 verbleibende Zeichen)
Vielen Dank für Ihr Feedback.

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2015 Microsoft