Márcio Fábio Althmann

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.