Observar variáveis com o Watch windows e o QuickWatch

Durante a depuração, você pode usar as janelas Watch e o QuickWatch para observar variáveis e expressões. As janelas só estão disponíveis durante uma sessão de depuração.

As janelas de observação podem exibir várias variáveis ao mesmo tempo 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 o QuickWatch, consulte Observe uma única variável ou expressão com o QuickWatch.

Observar 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 monitorizar os valores de a, b, e c no código a seguir:

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 linha c = a + b; clicando na margem esquerda, selecionando Depurar>Alternar Ponto de Interrupção ou pressionando F9.

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

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

   Você pode abrir mais janelas de observação selecionando as janelas 2, 3 ou 4.

4. Na janela Watch, selecione uma linha vazia e escreva a variável a. Faça o mesmo para b e c.

   

5. Continue a depuração selecionando Debug>Step Into ou pressionando F11 conforme necessário para avançar. Os valores das variáveis na janela Watch mudam à medida que iteras for pelo ciclo.

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

Pode observar qualquer expressão válida reconhecida pelo depurador numa janela Observação.

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

As regras para avaliar expressões na janela Watch são geralmente 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 círculo com o ícone de duas linhas onduladas pode aparecer na janela Watch. Esse ícone significa que o depurador não avalia a expressão por causa de uma possível dependência entre threads. A avaliação do 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 no estado do seu aplicativo, e o depurador pode ignorar eventos como pontos de interrupção e exceções nesses threads.

Atualizar valores de monitorizaçã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ço. O depurador tenta reavaliar a expressão. No entanto, você pode não querer ou ser capaz de reavaliar a expressão, dependendo do motivo pelo qual o valor não foi avaliado.

Passe o cursor sobre o ícone de atualização ou veja a coluna Valor pelo motivo pelo qual a expressão não foi avaliada. As razões incluem:

• Ocorreu um erro quando a expressão estava a ser 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 desencadear um efeito colateral no aplicativo. Ver Efeitos secundários da expressão.

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

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ê poderá 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 uma inspeção 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 Watch mostra algo como a seguinte mensagem:

   

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

Efeitos secundários em expressões

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

var1 = var2

Este código pode causar um efeito colateral. Os efeitos colaterais podem dificultar a depuração ao alterar a forma como a aplicação opera.

Uma expressão com efeitos secundários é avaliada apenas uma vez, quando a introduz pela primeira vez. Depois disso, a expressão aparece acinzentada na janela Watch e outras avaliações são desativadas. O tooltip 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 estiver desativada, você poderá forçar a avaliação adicionando o modificador de formato ac a um Nome de variável na janela Inspeção . Consulte Especificadores de formato em C#.

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

Às vezes você quer observar o comportamento de um objeto específico. Por exemplo, talvez você queira rastrear um objeto referido por uma variável local depois que essa variável tiver saído do escopo. Em C# e Visual Basic, você pode criar IDs de objeto para instâncias específicas de tipos de referência e usá-los na janela Watch e em condições de ponto de interrupção. A ID do objeto é gerada pelos serviços de depuração CLR (Common Language Runtime) e associada ao objeto.

No código a seguir, o MakePerson() método cria um Person usando 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 de Person no método DoSomething(), pode adicionar uma referência ao 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 pausar 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ê verá um cifrão ($) 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 a depurar. Quando pausa a execução no método DoSomething(), a janela Watch exibe o objeto Person.

   Se quiser ver as propriedades do objeto, como Person.Name, habilite a avaliação da propriedade.

   No painel Opções de Ferramentas (ou Depuração), na secção Todas as ConfiguraçõesDepuração Geral, selecione a caixa de seleção Ativar avaliação de propriedades e outras chamadas de função implícitas.

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

Visualização dinâmica e janela de observação

Algumas linguagens de script (por exemplo, JavaScript ou Python) usam tipagem dinâmica ou duck, e o .NET a partir da versão 4.0 suporta objetos que são difíceis de observar nas janelas normais de depuração.

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

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

Para exibir somente o Modo de Exibição Dinâmico 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 Visual Basic: $dynamic, ObjectName

Para inserir uma nova variável de vigilância que converte um objeto num objeto dinâmico:

1. Clique com o botão direito do rato em qualquer filho de uma Vista Dinâmica.
2. Escolha Adicionar relógio. O object.name torna-se ((dynamic) object).name e aparece em uma nova janela de observação .

O depurador também adiciona à janela Autos um nó filho da Visualização Dinâmica do objeto. 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 Modo de Exibição Dinâmico para o objeto.

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

Você pode usar o 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 é exibida. A a variável está na caixa Expressão com um Valor de 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 do QuickWatch . (O QuickWatch é uma caixa de diálogo modal, portanto, você não pode continuar a depuração enquanto ela estiver aberta.)

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

Conteúdo relacionado

• O que é despiste de erros?
• Técnicas e ferramentas de depuração
• Uma primeira abordagem à depuração
• janelas do depurador