Megosztás a következőn keresztül:

A hibakeresés javítása a hibakereső megjelenítési attribútumaival

Megjegyzés:

Ez a cikk a .NET-keretrendszerre vonatkozik. Ez nem vonatkozik a .NET újabb implementációira, beleértve a .NET 6-os és újabb verzióit.

A hibakereső megjelenítési attribútumai lehetővé teszik, hogy a típus fejlesztője, aki meghatározza és legjobban megértse az adott típus futtatókörnyezeti viselkedését, azt is megadhatja, hogy az adott típus hogyan fog kinézni, amikor egy hibakeresőben jelenik meg. Emellett a hibakereső megjelenítési attribútumai, amelyek egy Target tulajdonságot biztosítanak, alkalmazhatók a felhasználók által az assembly szintjén, a forráskód ismerete nélkül. Az DebuggerDisplayAttribute attribútum szabályozza, hogyan jelenik meg egy típus vagy tag a hibakereső változóablakaiban. Az DebuggerBrowsableAttribute attribútum határozza meg, hogy egy mező vagy tulajdonság megjelenjen-e és hogyan a hibakereső változóablakokban. Az DebuggerTypeProxyAttribute attribútum helyettesítő típust vagy proxyt ad meg egy típushoz, és megváltoztatja a típus megjelenését a hibakereső ablakokban. Ha proxyval vagy helyettesítő típussal rendelkező változót tekint meg, a proxy az eredeti típust jelöli a hibakereső megjelenítési ablakában. A hibakereső változó ablaka csak a proxytípus nyilvános tagjait jeleníti meg. A privát tagok nem jelennek meg.

A DebuggerDisplayAttribute használata

A DebuggerDisplayAttribute konstruktor egyetlen argumentumot tartalmaz: a típuspéldányok értékoszlopában megjelenítendő sztringet. Ez a sztring kapcsos zárójeleket ({ és }) tartalmazhat. A kapcsos zárójelek között lévő szöveg kifejezésként lesz kiértékelve. A következő C# kód például a "Darabszám = 4" értéket jeleníti meg, ha a pluszjel (+) ki van választva, hogy kibővítse a hibakereső felületet egy MyHashtable példánynál.

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

A kifejezésben hivatkozott tulajdonságokra alkalmazott attribútumok feldolgozása nem történik meg. A C#-fordító esetében engedélyezett egy általános kifejezés, amely csak implicit hozzáféréssel rendelkezik ehhez a hivatkozáshoz a céltípus aktuális példányához. A kifejezés korlátozott; nincs hozzáférés az aliasokhoz, a helyiekhez és a mutatókhoz. A C#-kódban olyan általános kifejezést használhat a zárójelek között, amelyek implicit hozzáféréssel rendelkezik a this mutatóhoz csak a céltípus aktuális példányához.

Ha például egy C#-objektum felülírt ToString(), a hibakereső meghívja a felülírt metódust, és az eredményét jeleníti meg a standard {<typeName>}. helyett. Így, ha felülírt ToString(), akkor nem kell használnia DebuggerDisplayAttribute. Ha mindkettőt használja, az DebuggerDisplayAttribute attribútum elsőbbséget élvez a ToString() felülbírálásnál.

A DebuggerBrowsableAttribute használata

Alkalmazza a DebuggerBrowsableAttribute mezőt egy mezőre vagy tulajdonságra annak megadásához, hogy a mező vagy tulajdonság hogyan jelenjen meg a hibakereső ablakban. Az attribútum konstruktora az DebuggerBrowsableState enumerálási értékek egyikét veszi fel, amely az alábbi állapotok egyikét adja meg:

  • Never azt jelzi, hogy a tag nem jelenik meg az adatablakban. Ha például ezt az értéket használja egy DebuggerBrowsableAttribute mezőhöz, azzal eltávolítja a mezőt a hierarchiából; a mező nem jelenik meg, ha a típuspéldány pluszjelére (+) kattintva bontja ki a befoglaló típust.

  • Collapsed azt jelzi, hogy a tag alapértelmezés szerint megjelenik, de nem bontható ki. Ez az alapértelmezett viselkedés.

  • RootHidden azt jelzi, hogy maga a tag nem jelenik meg, de a rendszerösszetevő objektumai akkor jelennek meg, ha tömb vagy gyűjtemény.

Megjegyzés:

A DebuggerBrowsableAttribute Visual Basic nem támogatja a .NET-keretrendszer 2.0-s verziójában.

Az alábbi példakód azt mutatja be, hogyan akadályozza meg a DebuggerBrowsableAttribute a rákövetkező tulajdonság megjelenését az osztály hibakeresési ablakában.

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

A DebuggerTypeProxy használata

Akkor használja az DebuggerTypeProxyAttribute attribútumot, ha egy típus hibakeresési nézetét jelentősen és alapvetően módosítania kell, de magát a típust nem. Az DebuggerTypeProxyAttribute attribútum egy típus megjelenítési proxyjának megadására szolgál, így a fejlesztő a nézetet a típushoz igazíthatja. Ez az DebuggerDisplayAttributeattribútum a szerelvény szintjén is használható, ebben az esetben a Target tulajdonság határozza meg, hogy milyen típusú proxyt használ a rendszer. Az ajánlott használat az, hogy ez az attribútum egy privát beágyazott típust határoz meg, amely abban a típusban fordul elő, amelyre az attribútumot alkalmazza. A típusmegjelenítőket támogató kifejezés-kiértékelő egy típus megjelenésekor ellenőrzi ezt az attribútumot. Ha az attribútum megtalálható, a kifejezésértékelő lecseréli a megjelenítési proxy típusát arra a típusra, amelyet az attribútum alkalmaz.

Amikor a DebuggerTypeProxyAttribute hibakereső változó jelen van, a hibakereső változóablak csak a proxytípus nyilvános tagjait jeleníti meg. A privát tagok nem jelennek meg. Az adatablak viselkedését az attribútumok által bővített nézetek nem módosítják.

A szükségtelen teljesítménybírságok elkerülése érdekében a megjelenítési proxy attribútumai nem lesznek feldolgozva, amíg ki nem bontják az objektumot, vagy a felhasználó az adatablakban a típus melletti pluszjelre (+) kattint, vagy az DebuggerBrowsableAttribute attribútum alkalmazásán keresztül. Ezért javasoljuk, hogy a megjelenítési típusra ne alkalmazzanak attribútumokat. Az attribútumok a megjelenítési típus törzsén belül alkalmazhatók.

Az alábbi példakód azt mutatja be, hogy a DebuggerTypeProxyAttribute hibakereső megjelenítési proxyjaként használandó típust adja meg.

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

példa

Leírás

Az alábbi példakód megtekinthető a Visual Studio szoftverben, hogy láthassa a DebuggerDisplayAttribute, DebuggerBrowsableAttribute, és DebuggerTypeProxyAttribute attribútumok alkalmazásának eredményeit.

Kód


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

Lásd még

  • Last updated on