Compartilhar via

Aprimorando a depuração com os atributos de exibição do depurador

  • Artigo

Atributos de exibição do depurador permitem que o desenvolvedor do tipo, que especifica e entenda melhor o comportamento em tempo de execução desse tipo, especifique também o que esse tipo de como ficarão quando ele for exibido em um depurador.Além disso, o depurador exibir atributos que fornecem um Target propriedade pode ser aplicada no nível do assembly por usuários sem conhecimento do código-fonte. The DebuggerDisplayAttribute atributo controla como um tipo ou membro é exibido no depurador variável janelas. The DebuggerBrowsableAttribute atributo determina se e como um campo ou propriedade é exibida nas janelas de variáveis do depurador. The DebuggerTypeProxyAttribute atributo especifica um tipo de substituto ou um proxy para um tipo e alterações a maneira como o tipo é exibido nas janelas depurador. Quando você exibir uma variável que possui um proxy ou tipo de substituição, o proxy significa o tipo original no depurador exibição janela . A janela do depurador de variável exibe somente os membros do tipo de proxy público.Membros particulares não são exibidos.

Usando o DebuggerDisplayAttribute

The DebuggerDisplayAttribute construtor tem um único argumento: uma seqüência a ser exibida na coluna valor de instâncias do tipo.Essa seqüência pode conter chaves ({e}).O texto dentro de um emparelhar de chaves será avaliado sistema autônomo uma expressão.Por exemplo, a seguir translation from VPE for Csharp código causas "Count = 4" para ser exibido quando o sinal de mais (+) é selecionado para expandir a exibição do depurador para uma instância deMyHashtable.

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

Atributos aplicados às propriedades mencionadas na expressão não são processados.Para o compilador translation from VPE for Csharp, uma expressão geral é permitida que tem apenas acesso implícito a esta referência para a instância corrente do tipo de destino.A expressão é limitada; há nenhum acesso para aliases, locais ou ponteiros.No código translation from VPE for Csharp, você pode usar uma expressão geral entre as chaves tem acesso implícito ao this ponteiro para a instância corrente do tipo de destino somente.

Por exemplo, se um objeto translation from VPE for Csharp tem uma substituir ToString(), o depurador irá chama a substituir e mostrar seu resultado em vez do padrão {<typeName>}. Portanto, se você tiver substituído ToString(), você não precisa usar DebuggerDisplayAttribute. Se você usar ambos, a DebuggerDisplayAttribute atributo tem precedência sobre o ToString() Substitua.

Usando o DebuggerBrowsableAttribute

Aplicar o DebuggerBrowsableAttribute para um campo ou propriedade para especificar como o campo ou propriedade será exibido na janela do depurador. O construtor para este atributo utiliza um o DebuggerBrowsableState valores de enumeração, que especifica um dos seguintes estados:

  • Never indica que o membro não é exibido na janela de dados. Por exemplo, usar esse valor para o DebuggerBrowsableAttribute em um campo remove o campo da hierarquia; o campo não é exibido quando você expande um tipo delimitador clicando no sinal de adição (+) para a instância do tipo.

  • Collapsed indica que o membro é exibido, mas não expandido por padrão. Esse é o comportamento padrão.

  • RootHidden indica que o próprio membro não é exibido, mas seus objetos constituintes serão exibidos se ele for uma matriz ou coleção.

Observação:

O DebuggerBrowsableAttribute não é suportado pelo Visual Basic no .NET estrutura versão 2.0.

O exemplo de código a seguir mostra o uso do DebuggerBrowsableAttribute Para evitar que a propriedade após ele apareça na janela de depurar para a classe.

[DebuggerBrowsable(DebuggerBrowsableState.Never)]
public static string y = "Test String";

Usando o DebuggerTypeProxy

Use o DebuggerTypeProxyAttribute Quando você precisa significativamente e altera fundamentalmente o modo de exibição de depuração de um tipo, mas não alterar o próprio tipo de atributo. The DebuggerTypeProxyAttribute atributo é usado para especificar um proxy de exibição para um tipo, permitindo que um desenvolvedor adaptar o modo de exibição para o tipo. Esse atributo, como a DebuggerDisplayAttribute, pode ser usado no nível do conjunto, caso em que o Target propriedade especifica o tipo para que o proxy será usado. O uso recomendado é que este atributo especifica um tipo aninhado particular que ocorre dentro do tipo ao qual o atributo é aplicado.Um avaliador da expressão suporta digite visualizadores verifica para este atributo quando um tipo é exibido.Se o atributo for encontrado, o avaliador da expressão substitui o tipo de proxy de exibição para o tipo a que de atributo é aplicado.

Quando o DebuggerTypeProxyAttribute está presente, a janela do depurador de variável exibe somente os membros públicos do tipo de proxy. Membros particulares não são exibidos.O comportamento da janela de dados não é alterado por modos de exibição avançado de atributo.

Para evitar penalidades de desempenho desnecessária, atributos de proxy de exibição não são processados até que o objeto estiver expandido, seja através o usuário clicar no sinal de mais (+) próximo ao tipo de em uma janela de dados ou através da aplicação do DebuggerBrowsableAttribute atributo. Portanto, recomenda-se que nenhum atributo seja aplicado para o tipo de exibição.Atributos podem e devem ser aplicados dentro do corpo do tipo de exibição.

O exemplo de código a seguir mostra o uso do DebuggerTypeProxyAttribute Para especificar um tipo a ser usado sistema autônomo um proxy de exibição do depurador.

[DebuggerTypeProxy(typeof(HashtableDebugView))]
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;
        }
    }
}

Exemplo

Descrição

O exemplo de código a seguir pode ser exibido em Visual Studio 2005 Para ver os resultados da aplicação a DebuggerDisplayAttribute, DebuggerBrowsableAttribute, e DebuggerTypeProxyAttribute atributos.

Código

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(myHashTable.ToString())
        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.
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    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(myHashTable.ToString());
        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}")]
[DebuggerTypeProxy(typeof(HashtableDebugView))]
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;
      }

      [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
      public KeyValuePairs[] Keys
      {
         get 
         {
             KeyValuePairs[] keys = new KeyValuePairs[hashtable.Count];

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

Consulte também

Referência

DebuggerDisplayAttribute

DebuggerBrowsableAttribute

DebuggerTypeProxyAttribute