DebuggerTypeProxyAttribute Classe

Definizione

Spazio dei nomi:

System.Diagnostics

Assembly:

System.Runtime.dll

Source:

DebuggerTypeProxyAttribute.cs

Specifica il proxy di visualizzazione per un tipo.

public ref class DebuggerTypeProxyAttribute sealed : Attribute

[System.AttributeUsage(System.AttributeTargets.Assembly | System.AttributeTargets.Class | System.AttributeTargets.Struct, AllowMultiple=true)]
public sealed class DebuggerTypeProxyAttribute : Attribute

[<System.AttributeUsage(System.AttributeTargets.Assembly | System.AttributeTargets.Class | System.AttributeTargets.Struct, AllowMultiple=true)>]
type DebuggerTypeProxyAttribute = class
    inherit Attribute

Public NotInheritable Class DebuggerTypeProxyAttribute
Inherits Attribute

Ereditarietà

Object

Attribute

DebuggerTypeProxyAttribute

Attributi

AttributeUsageAttribute

Esempio

Nell'esempio di codice seguente viene illustrato l'uso di DebuggerTypeProxyAttribute per specificare un tipo annidato privato da usare come proxy di visualizzazione del debugger. Questo esempio di codice fa parte di un esempio più ampio fornito per la DebuggerDisplayAttribute classe .

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

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

<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) 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

Commenti

Nota Usare questo attributo quando è necessario modificare in modo significativo e fondamentale la visualizzazione di debug di un tipo, ma non modificare il tipo stesso.

L'attributo DebuggerTypeProxyAttribute viene usato per specificare un proxy di visualizzazione per un tipo, consentendo a uno sviluppatore di personalizzare la vista per il tipo. Questo attributo può essere usato anche a livello di assembly, nel qual caso la Target proprietà specifica il tipo per cui verrà usato il proxy. In generale, questo attributo specifica un tipo annidato privato che si verifica all'interno del tipo a cui viene applicato l'attributo. Un analizzatore di espressioni che supporta i visualizzatori di tipo cerca questo attributo quando viene visualizzato un tipo. Se l'attributo viene trovato, l'analizzatore di espressioni sostituisce il tipo proxy di visualizzazione per il tipo a cui l'attributo viene applicato.

Quando DebuggerBrowsableAttribute è presente, nella finestra delle variabili del debugger vengono visualizzati soltanto i membri pubblici del tipo proxy. I membri privati non vengono visualizzati. Il comportamento della finestra dei dati non viene modificato dalle visualizzazioni avanzate dell'attributo.

Per evitare penalità non necessarie per le prestazioni, gli analizzatori di espressioni non devono esaminare gli attributi nel proxy di visualizzazione del tipo, a meno che il tipo non venga espanso, tramite l'utente che fa clic sul segno più (+) accanto al tipo in una finestra dati o tramite l'applicazione dell'attributo DebuggerBrowsableAttribute . È quindi consigliabile non applicare attributi al tipo visualizzato. È possibile e consigliabile applicare gli attributi nel corpo del tipo visualizzato.

Costruttori

DebuggerTypeProxyAttribute(String)	Inizializza una nuova istanza della classe DebuggerTypeProxyAttribute utilizzando il nome del tipo del proxy.
DebuggerTypeProxyAttribute(Type)	Inizializza una nuova istanza della classe DebuggerTypeProxyAttribute utilizzando il tipo del proxy.

Proprietà

ProxyTypeName	Ottiene il nome del tipo del proxy.
Target	Ottiene o imposta il tipo di destinazione per l'attributo.
TargetTypeName	Ottiene o imposta il nome del tipo di destinazione.
TypeId	Quando è implementata in una classe derivata, ottiene un identificatore univoco della classe Attribute. (Ereditato da Attribute)

Metodi

Equals(Object)	Restituisce un valore che indica se questa istanza è uguale a un oggetto specificato. (Ereditato da Attribute)
GetHashCode()	Restituisce il codice hash per l'istanza. (Ereditato da Attribute)
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
IsDefaultAttribute()	In caso di override in una classe derivata, indica se il valore di questa istanza è il valore predefinito per la classe derivata. (Ereditato da Attribute)
Match(Object)	Quando è sottoposto a override in una classe derivata, restituisce un valore che indica se questa istanza equivale a un oggetto specificato. (Ereditato da Attribute)
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)

Vedi anche

• Utilizzo dell'attributo DebuggerTypeProxy