Olá, tudo bem?

No nosso trabalho, passamos boa parte do tempo debugando, ou depurando aplicações, postei dois artigos sobre as novidades na depuração de código no Visual Studio 2010,aqui, aqui e aqui.

Esse três artigos que publiquei, mostram recursos do Visual Studio 2010, mas desde a versão 2.0 do .NET Framework, temos um atributo chamado DebuggerDisplay.

Com o DebuggerDisplay conseguimos definir, o que gostaríamos de ver facilmente, na janela onde podemos navegar entre as propriedades de uma classe durante a depuração do código.

Detalhe que o atributo não está limitado ao C#, podemos utilizar tranquilamento com VB.NET, F# e C++.

Vamos imaginar a classe Posicao abaixo, onde eu armazeno o valor X e Y de um determinado objeto de um jogo por exemplo.

class Posicao
{
    public int X { get; set; }
    public int Y { get; set; }
}

Agora instanciamos a classe, e definimos alguns valores.

static void Main(string[] args)
{
    var posicao = new Posicao {X = 50, Y = 100};
}

Essa é uma classe simples, mas da para ver bem o funcionamento do DebuggerDisplay. Agora compilando o programa, e depurando o mesmo, quero descobrir o valor de X e Y, então eu dependo da janela Locals onde posso navegar nas propriedades do objeto, ou navegando nos menus abertos sobre o objeto ao passar o mouse pelo mesmo.

Na imagem acima, da para ver que a coluna value, da janela Locals mostra o tipo do meu objeto, que nesse caso é OperadoresCSharp.Posicao, o mesmo ocorre com o menu flutuante, em ambos os casos eu preciso expandir o objeto para ver os valores das propriedades.

Agora utilizando o atributo DebuggerDisplay, que está no namespace System.Diagnostics eu consigo definir, por exemplo, quais propriedades da minha classe eu quero mostrar diretamente no lugar onde é mostrado o tipo do objeto.

[DebuggerDisplay("{X} {Y}")]
class Posicao
{
    public int X { get; set; }
    public int Y { get; set; }
}

No atributo, eu consigo colocar entre {} o nome de uma propriedade, que é o que fiz, agora na depuração já melhorou um pouco.

Já melhorou, só que ainda não é o ideal, o que é 50, 100? Só estou mostrando os valores das propriedades, mas não sei de qual propriedade é o valor 50 ou 100, felizmente conseguimos “nomear”, e fazer algo assim X = {X}.

[DebuggerDisplay("X={X} Y={Y}")]
class Posicao
{
    public int X { get; set; }
    public int Y { get; set; }
}

Agora sim, na hora de depurar o código, fica mais claro saber que o 50 é do X e 100 é do Y.

Mas isso funciona só com propriedades? Felizmente não, vamos imaginar que por algum motivo, é importante saber a soma de X e Y, e eu possuo um método chamado SomarValores(), consigo utilizar a mesma sintaxe passando ao invés do nome da propriedade, o nome do método, veja abaixo.

[DebuggerDisplay("X={X} Y={Y} Soma dos valores = {SomarValores()}")]
class Posicao
{
    public int X { get; set; }
    public int Y { get; set; }

    public int SomarValores()
    {
        return X + Y;
    }
}

Muito simples e útil, colocando um simples atributo, consigo definir valores úteis, que ajudem na hora da depuração do projeto.

Para finalziar, o atributo não está limitado a classes, posso utilizar com.

• Classes
• Structs
• Delegates
• Enumeradores
• Campos
• Propriedades
• Assemblies

Abraços e até o próximo post.