Introducción

Sé que hay gente que sigue la máxima de la información es poder, y de obtener información y conocimiento de muchos sitios y no compartir nada con el resto, algo que respeto pero que no comparto, ya que entre todos podemos recorrer más camino que uno sólo.

Pero lo mejor de todo es que no estoy sólo en ese camino, y me uno al grupo de entusiastas y apasionados de la tecnología que piensan igual que yo.

El caso es que recientemente, dos de esos apasionados escribieron en sus blogs un par de entradas precedidas antes por Twitter y a la que siguieron algunos comentarios muy interesantes.

En la primera de ellas, Luis Ruiz Pavón nos habló de como sobreescribir ToString en nuestras clases para mejorar la información en modo de depuración.

Otro fenómeno como es Eduard Tomás, complementó aquella entrada con otra no menos excelente titulada TIP – DebuggerDisplay.

Lo bueno es que leyendo estas entradas, uno reflexiona, piensa y recuerda, como así ha sido el caso, de la existencia de otras clases, en este caso de DebuggerBrowsable, del que quiero hablar aquí, y cuya existencia pasa muchas veces desapercibida para los desarrolladores, pero que creo complementa a las dos excelentes entradas de Luis y Eduard.

El objetivo de la depuración

El objetivo principal de la depuración es el de preguntar o interrogar como se están comportando nuestros procesos y nuestros objetos, sus flujos y qué información va y viene.

El problema a veces, es que manejamos gran cantidad de información en pantalla que nos impide ver con relativa facilidad algunos miembros o variables. Dicho de otro modo, hay miembros y variables cuya información no nos resulta relevante y… nos estorba cuando estamos depurando.

Por suerte, dentro de .NET tenemos la posibilidad de utilizar un atributo, de nombre DebuggerBrowsable, que nos permite ocultar o mostrar un nivel por encima aquellos miembros que nos interesa ver de un vistazo rápido.

La mejor manera de comprender esto bien, es haciendo un ejemplo, así que nos pondremos manos a la obra con C#.

Entendiendo el problema

En primer lugar, mostraremos el problema para posteriormente resolverlo.

Iniciaremos un proyecto de WinForms (aunque puede ser cualquier otro).

Crearemos dentro de él, dos clases. Una clase de nombre Team, y otra clase de nombre Driver.

Serán dos clases muy sencillas.

La primera clase Team tendrá el siguiente código:

namespace WindowsFormsApplication1
{
    public class Team
    {
 
        public string TeamName { get; set; }
        public string Country { get; set; }
        public Driver Name { get; set; }
    }
}

La segunda clase Driver tendrá el siguiente código:

namespace WindowsFormsApplication1
{
    public class Driver
    {
        public string Name { get; set; }
        public string Surname { get; set; }
        public byte Age { get; set; }
    }
}

Como podemos observar, son dos clases muy sencillas.

La primera corresponde a los datos de un equipo de Formula1, y la segunda contiene los datos de su primer piloto, con su nombre, apellido y edad.

Por su parte, nuestro formulario Windows contendrá el siguiente código fuente:

namespace WindowsFormsApplication1
{
    public partial class MainForm : Form
    {
 
        public MainForm()
        {
            InitializeComponent();
            Initialize();
        }
 
        private Team Formula1Team { get; set; }
 
        private void MainForm_Load(object sender, EventArgs e)
        {            
        }
 
        private void Initialize()
        { 
            this.Formula1Team = new Team() { TeamName = "Ferrari", 
                                             Country = "Italy", 
                                             Name = new Driver() 
                                                    { 
                                                        Name = "Fernando", 
                                                        Surname = "Alonso", 
                                                        Age = 32 
                                                     } 
                                            };
        }
 
    }
}

A continuación, pondremos un punto de interrupción después de agregar un objeto de tipo Team a Formula1Team y veremos la información que nos devuelve el depurador al posicionarnos encima de la propiedad Formula1Team.

La primera información que veremos en la que se indica en la siguiente imagen:

Algo que a todas luces es correcto.

Sin embargo, si queremos acceder a Name, observamos que es del tipo Driver, y nos obliga a hacer clic sobre Name para ver el contenido de esta clase:

El problema aquí es que hemos realizado dos pasos hasta llegar a parte de la información que nos interesaba.

¿Cómo resolver esto?. ¿Tenemos alguna manera de obtener la información que deseamos de un solo plumazo en el visualizador de depuración?.

La respuesta nos la da DebuggerBrowsable, el cual aún no hemos utilizado.

Entendiendo DebuggerBrowsable

Una vez que entendemos un poco la problemática (no en todos los proyectos nos encontraremos con esta problemática o con la necesidad que he expuesto como ejemplo), vamos a ver como resolverlo. Para ello, utilizaremos el atributo DebuggerBrowsable.

Este atributo pertenece al namespace System.Diagnostics, y puede ser agregado a propiedades y campos en clases y estructuras.

Por su parte, tiene tres valores enumerados posibles pertenecientes a DebuggerBrowsableState que son:

  • Collapsed: muestra el objeto contraído, pero permite visualizar el miembro y expandirlo con el objetivo de acceder a cualquier otro miembro que lo pueda contener.
  • Never: no muestra nunca el elemento.
  • RootHidden: oculta el elemento raiz, mostrando los elementos secundarios en el caso de que el elemento sea una colección o matriz de elementos.

Un detalle de este uso es que podemos combinar estos atributos dentro de las diferentes clases. En el ejemplo anterior, tenemos un objeto de tipo Team que contiene a su vez datos de tipo Driver.

En nuestro caso, lo que nos interesa es mostrar en el depurador la información del nombre del equipo y el nombre y apellido del piloto principal del equipo.

Empezaremos por el final.

El objetivo es que el depurador nos muestre una información similar a la que se indica a continuación:

Como podemos observar, lo que obtenemos por pantalla en nuestro caso, es más relevante y nos ayuda a centrarnos en la información que consideramos clave o más importante a la hora de depurar.

El código de nuestras clases Team y Driver, quedarán de la siguiente manera en este caso:

La clase Team quedará de la siguiente forma:

using System.Diagnostics;
 
namespace WindowsFormsApplication1
{
    public class Team
    {
 
        public string TeamName { get; set; }
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        public string Country { get; set; }
        [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
        public Driver Name { get; set; }
    }
}

La clase Driver quedará de la siguiente forma:

using System.Diagnostics;
 
namespace WindowsFormsApplication1
{
    public class Driver
    {
        public string Name { get; set; }
        public string Surname { get; set; }
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        public byte Age { get; set; }
    }
}

Obviamente, el resto de miembros del objeto está ahí y no han desaparecido. El Intellisense los localiza sin problemas y podemos acceder a ellos desde código.

Sin embargo y como podemos apreciar, el uso de este atributo nos puede venir bien en diferentes situaciones. Ahí cada uno debe saber si le aporta valor o no.