Controllare le variabili con le finestre Espressioni di controllo e controllo immediato

Durante il debug, è possibile usare le finestre Espressioni di controllo e Controllo immediato per controllare variabili ed espressioni. Le finestre sono disponibili solo durante una sessione di debug.

Le finestre espressioni di controllo possono visualizzare diverse variabili alla volta durante il debug. La finestra di dialogo Controllo immediato visualizza una singola variabile alla volta e deve essere chiusa prima che il debug possa continuare. Per altre informazioni sull'uso di QuickWatch, vedere Osservare una singola variabile o espressione con QuickWatch.

Nota

Se questa è la prima volta che si è tentato di eseguire il debug del codice, è possibile leggere Debug per principianti e tecniche e strumenti di debug assoluti prima di eseguire questo articolo.

Osservare le variabili con una finestra Espressioni di controllo

È possibile aprire più finestre espressione di controllo e osservare più variabili in una finestra Espressione di controllo.

Ad esempio, per impostare un controllo sui valori di a, be c nel codice seguente:

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. Impostare un punto di interruzione sulla c = a + b; riga facendo clic sul margine sinistro, selezionando Attiva>/Disattiva punto di interruzione o premendo F9.

2. Avviare il debug selezionando la freccia di avvio verde o Avvia debug> oppure premere F5. L'esecuzione viene sospesa in corrispondenza del punto di interruzione.

3. Aprire una finestra Espressione di controllo selezionando Debug>Espressione di controllo>di Windows>1 o premendo CTRL+ALT+W>1.

   È possibile aprire finestre espressioni di controllo aggiuntive selezionando windows 2, 3 o 4.

4. Nella finestra Espressione di controllo selezionare una riga vuota e digitare variabile a. Eseguire la stessa operazione per b e c.

   

5. Continuare il debug selezionando Esegui>debug in o premendo F11 in base alle esigenze. I valori delle variabili nella finestra Espressioni di controllo cambiano durante l'iterazione del for ciclo.

Nota

Solo per C++,

• Potrebbe essere necessario qualificare il contesto di un nome di variabile o un'espressione che usa un nome di variabile. Il contesto è la funzione, il file di origine o il modulo in cui si trova una variabile. Se è necessario qualificare il contesto, usare la sintassi dell'operatore di contesto (C++) nella finestra Nome nella finestra Espressione di controllo .

• È possibile aggiungere nomi di registrazione e nomi di variabile usando il nome> $<register o @<register name> nella finestra Espressione di controllo. Per altre informazioni, vedere Pseudovariables.

Usare espressioni in una finestra Espressioni di controllo

È possibile osservare qualsiasi espressione valida riconosciuta dal debugger in una finestra Espressione di controllo .

Ad esempio, per il codice nella sezione precedente, è possibile ottenere la media dei tre valori immettendo (a + b + c) / 3 nella finestra Espressione di controllo :

Le regole per la valutazione delle espressioni nella finestra Espressioni di controllo sono in genere le stesse delle regole per la valutazione delle espressioni nel linguaggio di codice. Se un'espressione presenta un errore di sintassi, prevedere lo stesso errore del compilatore dell'editor di codice. Ad esempio, un errore di digitatura nell'espressione precedente genera questo errore nella finestra Espressione di controllo:

Nella finestra Espressione di controllo può essere visualizzato un cerchio con due linee ondulate. Questa icona indica che il debugger non valuta l'espressione a causa di una potenziale dipendenza tra thread. La valutazione del codice richiede l'esecuzione temporanea di altri thread nell'app, ma poiché si è in modalità di interruzione, tutti i thread nell'app vengono in genere arrestati. Consentire l'esecuzione temporanea di altri thread può avere effetti imprevisti sullo stato dell'app e il debugger può ignorare eventi come punti di interruzione ed eccezioni in tali thread.

Cercare nella finestra Espressione di controllo

È possibile cercare parole chiave nelle colonne Nome, Valore e Tipo della finestra Espressione di controllo usando la barra di ricerca sopra ogni finestra. Premere INVIO o selezionare una delle frecce per eseguire una ricerca. Per annullare una ricerca in corso, selezionare l'icona "x" nella barra di ricerca.

Usare rispettivamente le frecce sinistra e destra (MAIUSC+F3 e F3) per spostarsi tra le corrispondenze trovate.

Per rendere la ricerca più o meno completa, usare l'elenco a discesa Cerca più approfondito nella parte superiore della finestra Espressioni di controllo per selezionare il numero di livelli profondi che si desidera cercare in oggetti annidati.

Aggiungere le proprietà nella finestra Espressione di controllo

Nota

Questa funzionalità è supportata in .NET Core 3.0 o versione successiva.

È possibile esaminare rapidamente gli oggetti in base alle relative proprietà nella finestra Espressione di controllo con lo strumento Proprietà associabili. Per usare questo strumento, passare il puntatore del mouse su una proprietà e selezionare l'icona a forma di puntina visualizzata o fare clic con il pulsante destro del mouse e selezionare l'opzione Aggiungi membro come preferito nel menu di scelta rapida risultante. Questa proprietà viene visualizzata all'inizio dell'elenco delle proprietà dell'oggetto e il nome e il valore della proprietà vengono visualizzati nella colonna Valore . Per rimuovere una proprietà, selezionare di nuovo l'icona a forma di puntina o selezionare l'opzione Rimuovi membro come preferito nel menu di scelta rapida .

È anche possibile attivare o disattivare i nomi delle proprietà e filtrare le proprietà non aggiunte quando si visualizza l'elenco delle proprietà dell'oggetto nella finestra Espressione di controllo. È possibile accedere a entrambe le opzioni selezionando i pulsanti nella barra degli strumenti sopra la finestra espressioni di controllo.

Aggiornare i valori dell'espressione di controllo

Un'icona di aggiornamento (freccia circolare) potrebbe essere visualizzata nella finestra Espressione di controllo quando viene valutata un'espressione. L'icona di aggiornamento indica un errore o un valore non aggiornato.

Per aggiornare il valore, selezionare l'icona di aggiornamento o premere la barra spaziatrice. Il debugger tenta di rivalutare l'espressione. Tuttavia, potrebbe non essere necessario o essere in grado di rivalutare l'espressione, a seconda del motivo per cui il valore non è stato valutato.

Passare il puntatore del mouse sull'icona di aggiornamento o visualizzare la colonna Valore per il motivo per cui l'espressione non è stata valutata. I motivi includono:

• Si è verificato un errore durante la valutazione dell'espressione, come nell'esempio precedente. Potrebbe verificarsi un timeout oppure una variabile potrebbe non rientrare nell'ambito.

• L'espressione ha una chiamata di funzione che potrebbe attivare un effetto collaterale nell'app. Vedere Effetti collaterali dell'espressione.

• La valutazione automatica delle proprietà e delle chiamate di funzione implicite è disabilitata.

Se l'icona di aggiornamento viene visualizzata perché la valutazione automatica delle proprietà e delle chiamate di funzione implicite è disabilitata, è possibile abilitarla selezionando Abilita valutazione delle proprietà e altre chiamate di funzione implicite in Strumenti>Opzioni>Debug>generale.

Per illustrare l'uso dell'icona di aggiornamento:

1. In Strumenti>Opzioni>debug>Generale deselezionare la casella di controllo Abilita valutazione proprietà e altre chiamate di funzione implicite.

2. Immettere il codice seguente e nella finestra Espressione di controllo impostare un controllo sulla list.Count proprietà .

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

3. Avviare il debug. La finestra Espressione di controllo mostra un messaggio simile al seguente:

   

4. Per aggiornare il valore, selezionare l'icona di aggiornamento o premere la barra spaziatrice. Il debugger rivaluta l'espressione.

Effetti collaterali dell'espressione

La valutazione di alcune espressioni può modificare il valore di una variabile o influire in caso contrario sullo stato dell'app. La valutazione della seguente espressione, ad esempio, comporta la modifica del valore di var1:

var1 = var2

Questo codice può causare un effetto collaterale. Gli effetti collaterali possono rendere il debug più difficile modificando il funzionamento dell'app.

Un'espressione con effetti collaterali viene valutata una sola volta, quando viene immessa per la prima volta. Successivamente, l'espressione viene visualizzata in grigio nella finestra Espressioni di controllo e altre valutazioni sono disabilitate. La descrizione comando o la colonna Valore spiega che l'espressione causa un effetto collaterale. È possibile forzare la rivalutazione selezionando l'icona di aggiornamento visualizzata accanto al valore.

Un modo per evitare la designazione degli effetti collaterali consiste nel disattivare la valutazione automatica della funzione. In Strumenti>Opzioni>debug>Generale deselezionare Abilita valutazione delle proprietà e altre chiamate di funzione implicite.

Solo per C#, quando la valutazione delle proprietà o delle chiamate di funzione implicite è disattivata, è possibile forzare la valutazione aggiungendo il modificatore di formato ac a una variabile Name nella finestra Espressione di controllo . Vedere Identificatori di formato in C#.

Usare GLI ID oggetto nella finestra Espressione di controllo (C# e Visual Basic)

A volte si vuole osservare il comportamento di un oggetto specifico. Ad esempio, potrebbe essere necessario tenere traccia di un oggetto a cui fa riferimento una variabile locale dopo che tale variabile è uscita dall'ambito. In C# e Visual Basic è possibile creare ID oggetto per istanze specifiche dei tipi di riferimento e usarle nella finestra Espressioni di controllo e nelle condizioni del punto di interruzione. L'ID oggetto viene generato dai servizi di debug di Common Language Runtime (CLR) e associato all'oggetto.

Nota

Gli ID oggetto creano riferimenti deboli che non impediscono il Garbage Collection dell'oggetto. Sono validi solo per la sessione di debug corrente.

Nel codice seguente il MakePerson() metodo crea un Person oggetto usando una variabile locale:

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");
    }
}

Per individuare il nome di Person nel DoSomething() metodo , è possibile aggiungere un riferimento all'ID Person oggetto nella finestra Espressione di controllo .

1. Impostare un punto di interruzione nel codice dopo la creazione dell'oggetto Person .

2. Avviare il debug.

3. Quando l'esecuzione viene sospesa nel punto di interruzione, aprire la finestra Variabili locali scegliendo Debug>variabili locali di Windows.>

4. Nella finestra Variabili locali fare clic con il pulsante destro del mouse sulla Person variabile e scegliere Imposta ID oggetto.

   Verrà visualizzato un segno di dollaro ($) più un numero nella finestra Variabili locali , ovvero l'ID oggetto.

5. Aggiungere l'ID oggetto alla finestra Espressione di controllo facendo clic con il pulsante destro del mouse sull'ID oggetto e scegliendo Aggiungi espressione di controllo.

6. Impostare un altro punto di interruzione nel DoSomething() metodo .

7. Continuare il debug. Quando l'esecuzione viene sospesa nel DoSomething() metodo , nella finestra Espressione di controllo viene visualizzato l'oggetto Person .

   Nota

   Per visualizzare le proprietà dell'oggetto, ad esempio Person.Name, è necessario abilitare la valutazione delle proprietà selezionando Strumenti>Opzioni>Debug>generale>Abilita valutazione proprietà e altre chiamate di funzione implicite.

Visualizzazione dinamica e finestra Espressione di controllo

Alcuni linguaggi di scripting ,ad esempio JavaScript o Python, usano la digitazione dinamica o anatra e .NET versione 4.0 e versioni successive supportano oggetti difficili da osservare nelle normali finestre di debug.

Nella finestra Espressione di controllo questi oggetti vengono visualizzati come oggetti dinamici, creati da tipi che implementano l'interfaccia IDynamicMetaObjectProvider . I nodi oggetto dinamico mostrano i membri dinamici degli oggetti dinamici, ma non consentono la modifica dei valori dei membri.

Per aggiornare i valori di Visualizzazione dinamica, selezionare l'icona di aggiornamento accanto al nodo oggetto dinamico.

Per visualizzare solo la visualizzazione dinamica per un oggetto, aggiungere un identificatore di formato dinamico dopo il nome dell'oggetto dinamico nella finestra Espressione di controllo :

• Per C#: ObjectName, dynamic
• Per Visual Basic: $dynamic, ObjectName

Nota

• Il debugger C# non rivaluta automaticamente i valori nella visualizzazione dinamica quando si esegue il passaggio alla riga di codice successiva.
• Il debugger di Visual Basic aggiorna automaticamente le espressioni aggiunte tramite la visualizzazione dinamica.
• La valutazione dei membri di un visualizzazione dinamica può avere effetti collaterali.

Per inserire una nuova variabile watch che esegue il cast di un oggetto a un oggetto dinamico:

1. Fare clic con il pulsante destro del mouse su qualsiasi elemento figlio di una visualizzazione dinamica.
2. Scegliere Aggiungi espressione di controllo. Diventa object.name((dynamic) object).name e viene visualizzato in una nuova finestra Espressione di controllo .

Il debugger aggiunge anche un nodo figlio Visualizzazione dinamica dell'oggetto alla finestra Auto . Per aprire la finestra Auto, durante il debug selezionare Debug>di Windows>Auto.

Visualizzazione dinamica migliora anche il debug per gli oggetti COM. Quando il debugger passa a un oggetto COM sottoposto a wrapping in System.__ComObject, aggiunge un nodo Visualizzazione dinamica per l'oggetto .

Osservare una singola variabile o espressione con QuickWatch

È possibile usare QuickWatch per osservare una singola variabile.

Ad esempio, per il codice seguente:

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

Per osservare la a variabile,

1. Impostare un punto di interruzione nella riga a = a + b; .

2. Avviare il debug. L'esecuzione viene sospesa in corrispondenza del punto di interruzione.

3. Selezionare la variabile a nel codice.

4. Selezionare Debug>Controllo immediato, premere MAIUSC+F9 oppure fare clic con il pulsante destro del mouse e selezionare Controllo immediato.

   Verrà visualizzata la finestra di dialogo Controllo immediato. La a variabile si trova nella casella Espressione con valore1.

   

5. Per valutare un'espressione usando la variabile, digitare un'espressione, ad a + b esempio nella casella Espressione , e selezionare Rivalutazione.

   

6. Per aggiungere la variabile o l'espressione da Controllo immediato alla finestra Espressione di controllo, selezionare Aggiungi espressione di controllo.

7. Selezionare Chiudi per chiudere la finestra Controllo immediato. Il controllo immediato è una finestra di dialogo modale, quindi non è possibile continuare il debug finché è aperto.

8. Continuare il debug. È possibile osservare la variabile nella finestra Espressione di controllo .

Contenuto correlato

• Che cos'è il debug?
• Tecniche e strumenti di debug
• Esaminare prima di tutto il debug
• Finestre del debugger