Few Tips on Customizing Debugging Window View in Visual Studio

In this post, I am going to discuss a few tips on customizing debugging windows. This may be very helpful during debugging of an application. While debugging, you may want to simplify debug window or you may want to clean up all the unnecessary fields that are not important during debugging from debugging windows. Here are a few tips for customization of debug window.

Use DebuggerBrowsable attribute to customize the debugging windows:

Use DebuggerDisplay attribute to customize the debugging display.

To use the above attributes, you have to use System.Diagnostics namespace.

1. Using DebuggerBrowsable Attributes

If you want to customize the view on debugger window for any properties during debugging, you can easily do it using DebuggerBrowsable attributes. You can apply these attributes for any properties, fields or for Indexer. DebuggerBrowsable attributes constructor takes DebuggerBrowsableState as argument. DebuggerBrowsableState is used to provide the instruction to debugger about how it is going to be displayed in the debugger window.

We can provide three states for DebuggerBrowsable attributes:

1. Collapsed: If we set DebuggerBrowsableState as collapsed, then the debugger window will show the element as collapsed. It’s the default behavior.
2. Never: It will never show the element in debugging window.
3. RootHidden: It will hide the root elements and display all child items as expanded view.

You can read the complete definition of these DebuggerBrowsableState at MSDN.

Now I am going to demonstrate the use of this DebuggerBrowsable attributes and DebuggerBrowsableState using an example.

Before starting, let’s consider having the following code block:

namespace DebuggerDemo
{
    /// <summary>
    /// Student Info Demo Class
    /// </summary>
    class Program
    {
        /// <summary>
        /// Mains the specified args.
        /// </summary>
        /// <param name="args">The args.</param>
        static void Main(string[] args)
        {
            List<Student> student = new List<Student>();
            student.Add(new Student { Roll = 1, Name = "Abhijit", Marks = 87, 
		Addresses = new Address { Address1 = "add1", Address2 = "add2" } });
            student.Add(new Student { Roll = 2, Name = "Abhishek", Marks = 41, 
		Addresses = new Address { Address1 = "add3", Address2 = "add4" } });
            student.Add(new Student { Roll = 3, Name = "Rahul", Marks = 67, 
		Addresses = new Address { Address1 = "add5", Address2 = "" } });
            student.Add(new Student { Roll = 4, Name = "Sunil", Marks = 91, 
		Addresses = new Address { Address1 = "add11", Address2 = "add122" } });
            student.Add(new Student { Roll = 5, Name = "Atul", Marks = 71, 
		Addresses = new Address { Address1 = "add12", Address2 = "add222" } });
            student.Add(new Student { Roll = 6, Name = "Kunal", Marks = 71, 
		Addresses = new Address { Address1 = "add12", Address2 = "add222" } });
        }
    }

    /// <summary>
    /// Student Class
    /// </summary>
    class Student
    {
        /// <summary>
        /// Gets or sets the roll.
        /// </summary>
        /// <value>The roll.</value>
        public int Roll { get; set; }

        /// <summary>
        /// Gets or sets the name.
        /// </summary>
        /// <value>The name.</value>
        public string Name { get; set; }

        /// <summary>
        /// Gets or sets the marks.
        /// </summary>
        /// <value>The marks.</value>
        public int Marks { get; set; }

        /// <summary>
        /// Gets or sets the addresses.
        /// </summary>
        /// <value>The addresses.</value>
        public Address Addresses { get; set; }
    }

    /// <summary>
    /// Address of Students
    /// </summary>
    class Address
    {
        /// <summary>
        /// Gets or sets the address1.
        /// </summary>
        /// <value>The address1.</value>
        public string Address1 { get; set; }

        /// <summary>
        /// Gets or sets the address2.
        /// </summary>
        /// <value>The address2.</value>
        public string Address2 { get; set; }
    }
}

Now, first let’s see how the normal debugging window behaves. Just put a breakpoint at the end of main method and try to explore the debugging window. You will get a debugging window as the below picture, which is the expected debugging window view.

In the above picture, you can see that we are having 6 student objects and each one having a different value. As Addresses is a different class and used as properties with multiple values, hence it is in the collapsed mode.

Now, I want to see all the addresses along with all other properties with expanded mode and also want to hide the Marks properties. To achieve the above requirement, we have to add DebuggerBrowsable attributes for the Marks and Addresses properties in the Student class.

Now if you put the breakpoint in the same location and explore the debugging window, you will find the debugging window view as the below picture:

So, from the above picture, you can easily identify the changes in the debugging window view.

2. Use DebuggerDisplay Attribute

Here is the second tip. By using DebuggerDisplay attributes, you can define how a class or field will be displayed in the debugger window. Using DebuggerDisplay, you can change the debugger window message and variables that you want to display.

If you consider the above code sample and debug the application, by default, you will get the below snaps of debugging:

Here, for each student object, you are getting NameSpace.ClassName as display message by default. Now we can customize the display using DebuggerDisplay attributes. DebuggerDisplay attributes constructors take display name as arguments or you can pass the named parameter that you want to display over there.

After making the above changes, if you run the same code you will find that custom display message with proper value of parameter that you have given in debuggerdisplay attributes.

While using DebuggerDisplay, you have to make sure that you are giving the proper field name as argument within { }. Otherwise, you will get message like below:

In this blog post, I have explained how we can customize the debugging window’s view during debugging of our application using DebuggerBrowsable and DebuggerDisplay attributes. This is quite helpful while you are debugging a complex object and you want to make your debug window very simple.

Hope the above tips will help you in customizing debugging windows.

Filed under: General, Tips and Tricks, Visual Studio