Observar variáveis com Janelas de Watch e QuickWatch

Durante a depuração, você pode usar janelas de inspeção e QuickWatch para observar variáveis e expressões. As janelas ficam disponíveis apenas durante uma sessão de depuração.

As janelas de observação podem exibir várias variáveis simultaneamente durante a depuração. A caixa de diálogo QuickWatch exibe uma única variável de cada vez e deve ser fechada antes que a depuração possa continuar. Para obter mais informações sobre como usar QuickWatch, consulte Observe uma única variável ou expressão com QuickWatch.

Observe variáveis com uma janela de Observação

Você pode abrir mais de uma janela Watch e observar mais de uma variável em uma janela Watch.

Por exemplo, para monitorar os valores de a, b e c no seguinte código:

int main()
{
    int a, b, c;
    a = 1;
    b = 2;
    c = 0;

    for (int i = 0; i < 10; i++)
    {
        a++;
        b *= 2;
        c = a + b;
    }

    return 0;
}

1. Defina um ponto de interrupção na c = a + b; linha clicando na margem esquerda, selecionando Depurar>Alternar Ponto de Interrupção ou pressionando F9.

2. Inicie a depuração selecionando a seta inicial verde ou a depuração>iniciar a depuração ou pressione F5. A execução pausa no ponto de interrupção.

3. Abra uma janela Watch selecionando Depurar>Windows>Watch>Watch 1 ou pressionando Ctrl+Alt+W>1.

   Você pode abrir mais janelas Watch selecionando as janelas 2, 3 ou 4.

4. Na janela Assistir, selecione uma linha vazia e digite a variável a. Faça o mesmo por b e c.

   

5. Continue debugando selecionando Depurar>Passo a Passo ou pressionando F11 conforme necessário para avançar. Os valores de variável na janela Inspeção são alterados conforme você itera pelo for loop.

Usar expressões em uma janela de Observação

Você pode observar qualquer expressão válida reconhecida pelo depurador em uma janela Watch.

Por exemplo, para o código na seção anterior, você pode obter a média dos três valores entrando (a + b + c) / 3 na janela Assistir:

As regras para avaliar expressões na janela Inspeção geralmente são as mesmas que as regras para avaliar expressões na linguagem de código. Se uma expressão tiver um erro de sintaxe, espere o mesmo erro do compilador que no editor de código. Por exemplo, um erro de digitação na expressão anterior produz esse erro na janela Inspeção :

Um ícone de círculo com duas linhas onduladas pode aparecer na janela Watch. Esse ícone significa que o depurador não avalia a expressão devido a uma possível dependência entre threads. Avaliar o código requer que outros threads em seu aplicativo sejam executados temporariamente, mas como você está no modo de interrupção, todos os threads em seu aplicativo geralmente são interrompidos. Permitir que outros threads sejam executados temporariamente pode ter efeitos inesperados sobre o estado do seu aplicativo, e o depurador pode ignorar eventos como pontos de interrupção e exceções nesses threads.

Atualizar valores de monitoração

Um ícone de atualização (seta circular) pode aparecer na janela Inspeção quando uma expressão é avaliada. O ícone de atualização indica um erro ou um valor desatualizado.

Para atualizar o valor, selecione o ícone de atualização ou pressione a barra de espaços. O depurador tenta reavaliar a expressão. No entanto, talvez você não queira ou seja capaz de reavaliar a expressão, dependendo do motivo pelo qual o valor não foi avaliado.

Passe o mouse sobre o ícone de atualização ou veja a coluna Valor pelo motivo pelo qual a expressão não foi avaliada. Os motivos incluem:

• Ocorreu um erro quando a expressão estava sendo avaliada, como no exemplo anterior. Pode ocorrer um tempo limite ou uma variável pode estar fora do escopo.

• A expressão tem uma chamada de função que pode disparar um efeito colateral no aplicativo. Veja os efeitos colaterais da expressão.

• A avaliação automática de propriedades e chamadas de função implícitas está desabilitada.

Se o ícone de atualização aparecer porque a avaliação automática de propriedades e chamadas de função implícitas está desabilitada, você pode atualizar a configuração de depuração no menuOpções de >.

Para demonstrar como usar o ícone de atualização:

2. Insira o código a seguir e, na janela Inspeção , defina um relógio na list.Count propriedade.

   static void Main(string[] args)
   {
       List<string> list = new List<string>();
       list.Add("hello");
       list.Add("goodbye");
   }
   

3. Inicie a depuração. A janela Observação mostra algo parecido com a seguinte mensagem:

   

4. Para atualizar o valor, selecione o ícone de atualização ou pressione a barra de espaços. O depurador reavalia a expressão.

Efeitos colaterais da expressão

Avaliar algumas expressões pode alterar o valor de uma variável ou afetar o estado do aplicativo. Por exemplo, avaliar a expressão a seguir altera o valor de var1:

var1 = var2

Esse código pode causar um efeito colateral. Os efeitos colaterais podem tornar a depuração mais difícil, ao alterarem a forma como seu aplicativo funciona.

Uma expressão com efeitos colaterais é avaliada apenas uma vez, quando você a insere pela primeira vez. Depois disso, a expressão aparece acinzentada na janela Watch, e outras avaliações são desabilitadas. A dica de ferramenta ou a coluna Valor explica que a expressão causa um efeito colateral. Você pode forçar a reavaliação selecionando o ícone de atualização que aparece ao lado do valor.

Somente para C#, quando a avaliação de propriedades ou chamadas de função implícitas é desativada, você pode forçar a avaliação adicionando o modificador de formato ac a um Nome de variável na janela Watch. Consulte especificadores de formato em C#.

Usar IDs de objeto na janela Inspeção (C# e Visual Basic)

Às vezes, você deseja observar o comportamento de um objeto específico. Por exemplo, talvez você queira rastrear um objeto referenciado por uma variável local depois que essa variável tiver saído do escopo. No C# e no Visual Basic, você pode criar IDs de objeto para instâncias específicas de tipos de referência e usá-los na janela Observação e em condições de ponto de interrupção. O ID do objeto é gerado pelos serviços de depuração CLR (common language runtime) e associado ao objeto.

No código a seguir, o MakePerson() método cria um Person utilizando uma variável local.

class Person
{
    public Person(string name)
    {
        Name = name;
    }
    public string Name { get; set; }
}

public class Program
{
    static List<Person> _people = new List<Person>();
    public static void Main(string[] args)
    {
        MakePerson();
        DoSomething();
    }

    private static void MakePerson()
    {
        var p = new Person("Bob");
        _people.Add(p);
    }

    private static void DoSomething()
    {
        // more processing
         Console.WriteLine("done");
    }
}

Para descobrir o nome do Person no método DoSomething(), você pode adicionar uma referência à ID do Objeto Person na janela Inspeção.

1. Defina um ponto de interrupção no código após a criação do Person objeto.

2. Inicie a depuração.

3. Quando a execução for pausada no ponto de interrupção, abra a janela Locais escolhendo Depurar>Windows>Locais.

4. Na janela Locais , clique com o botão direito do mouse na Person variável e selecione Criar ID do Objeto.

   Você deve ver um sinal de dólar ($) mais um número na janela Locais , que é a ID do Objeto.

5. Adicione a ID do objeto à janela Inspeção clicando com o botão direito do mouse na ID do Objeto e selecionando Adicionar Inspeção.

6. Defina outro ponto de interrupção no DoSomething() método.

7. Continue debugando. Quando a execução pausa no DoSomething() método, a janela Inspeção exibe o Person objeto.

   Se você quiser ver as propriedades do objeto, como Person.Name, você deve habilitar a avaliação da propriedade.

   No painel Ferramentas (ou Depurar) >Opções, na seção Todas as Configurações>Depuração>Geral, selecione a caixa de seleção Habilitar avaliação de propriedade e outras chamadas de função implícitas.

   Na caixa de diálogo Ferramentas (ou Depurar) >Opções, na seção de Depuração>Geral, selecione a caixa de seleção Habilitar avaliação de propriedade e outras chamadas de função implícitas.

Visualização Dinâmica e a janela de Inspeção

Algumas linguagens de script (por exemplo, JavaScript ou Python) usam digitação dinâmica ou duck typing, e as versões 4.0 e posteriores do .NET oferecem suporte a objetos que são difíceis de observar nas janelas de depuração normais.

A janela Inspeção exibe esses objetos como objetos dinâmicos, que são criados a partir de tipos que implementam a IDynamicMetaObjectProvider interface. Nós de objeto dinâmico mostram os membros dinâmicos dos objetos dinâmicos, mas não permitem a edição dos valores dos membros.

Para atualizar os valores do Modo de Exibição Dinâmica , selecione o ícone de atualização ao lado do nó de objeto dinâmico.

Para exibir apenas a Exibição Dinâmica de um objeto, adicione um especificador de formato dinâmico após o nome do objeto dinâmico na janela Inspeção :

• Para C#: ObjectName, dynamic
• Para o Visual Basic: $dynamic, ObjectName

Para inserir uma nova variável de inspeção que converte um objeto em um objeto dinâmico:

1. Clique com o botão direito em qualquer subitem de um Modo de Exibição Dinâmico.
2. Escolha Adicionar Monitoramento. O object.name torna-se ((dynamic) object).name e aparece em uma nova janela Watch.

O depurador também adiciona um nó filho Dynamic View do objeto à janela Autos. Para abrir a janela Autos , durante a depuração, selecione Depurar>Windows>Autos.

O Modo de Exibição Dinâmico também aprimora a depuração de objetos COM. Quando o depurador chega a um objeto COM encapsulado em System.__ComObject, ele adiciona um nó de Exibição Dinâmica para o objeto.

Observar uma única variável ou expressão com QuickWatch

Você pode usar QuickWatch para observar uma única variável.

Por exemplo, para o seguinte código:

static void Main(string[] args)
{
    int a, b;
    a = 1;
    b = 2;
    for (int i = 0; i < 10; i++)
    {
        a = a + b;
    }
}

Para observar a a variável,

1. Defina um ponto de interrupção na linha a = a + b;.

2. Inicie a depuração. A execução pausa no ponto de interrupção.

3. Selecione a variável a no código.

4. Selecione Depurar>QuickWatch, pressione Shift+F9 ou clique com o botão direito do mouse e selecione QuickWatch.

   A caixa de diálogo QuickWatch aparece. A a variável está na caixa Expressão com um Valorde 1.

   

5. Para avaliar uma expressão usando a variável, digite uma expressão como a + b na caixa Expressão e selecione Reavaliar.

   

6. Para adicionar a variável ou expressão do QuickWatch à janela Inspeção , selecione Adicionar Inspeção.

7. Selecione Fechar para fechar a janela QuickWatch . (QuickWatch é uma caixa de diálogo modal, portanto, você não pode continuar depurando enquanto ele estiver aberto.)

8. Continue debugando. Você pode observar a variável na janela Inspeção.

Conteúdo relacionado

• O que é depuração?
• Técnicas e ferramentas de depuração
• Primeira olhada na depuração
• Janelas do depurador