Enhancing Debugging with the Debugger Display Attributes

Debugger display attributes allow the developer of the type, who specifies and best understands the runtime behavior of that type, to also specify what that type will look like when it is displayed in a debugger. In addition, debugger display attributes that provide a Target property can be applied at the assembly level by users without knowledge of the source code. The DebuggerDisplayAttribute attribute controls how a type or member is displayed in the debugger variable windows. The DebuggerBrowsableAttribute attribute determines if and how a field or property is displayed in the debugger variable windows. The DebuggerTypeProxyAttribute attribute specifies a substitute type, or a proxy, for a type and changes the way the type is displayed in debugger windows. When you view a variable that has a proxy, or substitute type, the proxy stands in for the original type in the debugger display window**.** The debugger variable windowdisplays only the public members of the proxy type. Private members are not displayed.

Using the DebuggerDisplayAttribute

The DebuggerDisplayAttribute constructor has a single argument: a string to be displayed in the value column for instances of the type. This string can contain braces ({ and }). The text within a pair of braces is evaluated as an expression. For example, the following C# code causes "Count = 4" to be displayed when the plus sign () is selected to expand the debugger display for an instance of MyHashtable.

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

Attributes applied to properties referenced in the expression are not processed. For the C# compiler, a general expression is allowed that has only implicit access to this reference for the current instance of the target type. The expression is limited; there is no access to aliases, locals, or pointers. In C# code, you can use a general expression between the braces that has implicit access to the this pointer for the current instance of the target type only.

For example, if a C# object has an overridden ToString(), the debugger will call the override and show its result instead of the standard {<typeName>}. Thus, if you have overridden ToString(), you do not need to use DebuggerDisplayAttribute. If you use both, the DebuggerDisplayAttribute attribute takes precedence over the ToString() override.

Using the DebuggerBrowsableAttribute

Apply the DebuggerBrowsableAttribute to a field or property to specify how the field or property is to be displayed in the debugger window. The constructor for this attribute takes one of the DebuggerBrowsableState enumeration values, which specifies one of the following states:

  • Never indicates that the member is not displayed in the data window. For example, using this value for the DebuggerBrowsableAttribute on a field removes the field from the hierarchy; the field is not displayed when you expand the enclosing type by clicking the plus sign () for the type instance.

  • Collapsed indicates that the member is displayed but not expanded by default. This is the default behavior.

  • RootHidden indicates that the member itself is not shown, but its constituent objects are displayed if it is an array or collection.


The DebuggerBrowsableAttribute is not supported by Visual Basic in the .NET Framework version 2.0.

The following code example shows the use of the DebuggerBrowsableAttribute to prevent the property following it from appearing in the debug window for the class.

public static string y = "Test String";

Using the DebuggerTypeProxy

Use the DebuggerTypeProxyAttribute attribute when you need to significantly and fundamentally change the debugging view of a type, but not change the type itself. The DebuggerTypeProxyAttribute attribute is used to specify a display proxy for a type, allowing a developer to tailor the view for the type. This attribute, like the DebuggerDisplayAttribute, can be used at the assembly level, in which case the Target property specifies the type for which the proxy will be used. The recommended usage is that this attribute specifies a private nested type that occurs within the type to which the attribute is applied. An expression evaluator that supports type viewers checks for this attribute when a type is displayed. If the attribute is found, the expression evaluator substitutes the display proxy type for the type the attribute is applied to.

When the DebuggerTypeProxyAttribute is present, the debugger variable window displays only the public members of the proxy type. Private members are not displayed. The behavior of the data window is not changed by attribute-enhanced views.

To avoid unnecessary performance penalties, attributes of the display proxy are not processed until the object is expanded, either through the user clicking the plus sign () next to the type in a data window, or through the application of the DebuggerBrowsableAttribute attribute. Therefore, it is recommended that no attributes be applied to the display type. Attributes can and should be applied within the body of the display type.

The following code example shows the use of the DebuggerTypeProxyAttribute to specify a type to be used as a debugger display proxy.

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;



The following code example can be viewed in Visual Studio 2005 to see the results of applying the DebuggerDisplayAttribute, DebuggerBrowsableAttribute, and DebuggerTypeProxyAttribute attributes.


Imports System
Imports System.Collections
Imports System.Diagnostics
Imports System.Reflection

Class DebugViewTest

    Shared Sub Main(ByVal args() As String) 
        Dim myHashTable As New MyHashtable()
        myHashTable.Add("one", 1)
        myHashTable.Add("two", 2)
        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 Const TestString As String = "This should appear in the debug window." 

        Public Sub New(ByVal hashtable As Hashtable)
            Me.hashtable = hashtable

        End Sub 'New 
    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.
    public static string y = "Test String";

    static void Main(string[] args)
        MyHashtable myHashTable = new MyHashtable();
        myHashTable.Add("one", 1);
        myHashTable.Add("two", 2);
        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}")]
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;

      public KeyValuePairs[] Keys
             KeyValuePairs[] keys = new KeyValuePairs[hashtable.Count];

            int i = 0;
            foreach(object key in hashtable.Keys)
               keys[i] = new KeyValuePairs(hashtable, key, hashtable[key]);
         return keys;

See Also