Esaminare le variabili e restituire i valori nel debugger di Visual Studio

Quando si tenta di eseguire il debug di un problema, spesso si tenta di scoprire se le variabili archiviano i valori previsti per uno stato specifico dell'app. Alcune delle funzionalità più utili del debugger sono quelle che consentono di esaminare le variabili.

Questo articolo illustra come esaminare le variabili e visualizzare i valori restituiti usando il debugger in Visual Studio. Il debugger offre diversi modi pratici per eseguire queste attività, tra cui:

• Nell'editor di codice è possibile visualizzare i suggerimenti per i dati e i valori restituiti in linea
• Nelle finestre del debugger (finestre Automatiche, Locali e di Controllo) è possibile visualizzare i valori delle variabili
• Nei visualizzatori è possibile visualizzare stringhe di grandi dimensioni o oggetti .NET complessi

Queste funzionalità sono disponibili solo durante il debug. Per informazioni su come avviare una sessione di debug, vedere Avviare il debug e attivare la modalità di interruzione.

Nota

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

Visualizzare le variabili nell'editor di codice

Spesso, quando si esegue il debug, si vuole un modo rapido per controllare i valori delle proprietà sugli oggetti nell'editor di codice e i suggerimenti per i dati sono un buon modo per farlo.

Mentre il debugger è in pausa, passa il puntatore su un oggetto per visualizzarne il valore o il valore predefinito della proprietà.

Se la variabile ha proprietà, è possibile espandere l'oggetto per visualizzarne tutte le proprietà.

Per informazioni dettagliate sull'uso dei suggerimenti per i dati, vedere Visualizzare i valori dei dati nei suggerimenti per i dati.

Visualizzare i valori restituiti inline delle chiamate al metodo nell'editor di codice

Nel codice .NET e C++ è possibile esaminare i valori restituiti quando si estrae o si esce da una chiamata al metodo, che può essere utile quando il valore restituito non viene archiviato in una variabile locale. Un metodo può essere usato come parametro o come valore restituito di un altro metodo.

A partire da Visual Studio 2022 versione 17.12, è possibile visualizzare i valori restituiti delle chiamate al metodo inline e non solo nella finestra Auto.

Con Copilot abilitato, è anche possibile ottenere assistenza mirata relativa al valore restituito in linea usando il pulsante "Ask Copilot" visualizzato nel suggerimento dei dati per il valore restituito.

Impostare un controllo sulle variabili

È possibile usare una finestra di osservazione per specificare una variabile (o un'espressione) da tenere d'occhio.

Durante il debug, fare clic con il pulsante destro del mouse su un oggetto nell'editor di codice e scegliere Aggiungi monitor. Verrà visualizzata una finestra Espressione di controllo.

In questo esempio è presente un watch set nell'oggetto ed è possibile visualizzarne la modifica durante lo spostamento nel debugger. A differenza delle altre finestre delle variabili, le finestre Watch mostrano sempre le variabili che si stanno osservando (sono in grigio, quando non rientrano nell'ambito).

Per informazioni dettagliate, vedere Impostare un punto di osservazione utilizzando le finestre Espressione di controllo e Controllo rapido.

Ottenere assistenza per l'intelligenza artificiale

Se si ha Copilot, è possibile ottenere assistenza per l'intelligenza artificiale durante l'analisi delle variabili nell'editor di codice o nelle finestre Auto o Variabili locali. Durante il debug, fare clic con il pulsante destro del mouse su una variabile e usare il pulsante Ask Copilot In questo scenario Copilot conosce già il contesto per la domanda, quindi non è necessario fornire il contesto in chat. Per altre informazioni, vedere Debug con Copilot.

Esaminare le variabili nelle finestre del debugger (Variabili automatiche e Locali)

Le finestre Autos e Locals mostrano i valori delle variabili mentre si esegue il debug. Le finestre sono disponibili solo durante una sessione di debug. La finestra Autos mostra le variabili usate nella corrente istruzione in cui il debugger è sospeso. La finestra variabili locali mostra le variabili definite nell'ambito locale, che è in genere la funzione o il metodo corrente.

• Per aprire la finestra Auto, durante il debug selezionare Debug>Windows>Autooppure premere CTRL+ALT+V>A.

  La finestra auto è disponibile per il codice C#, Visual Basic, C++ e Python, ma non per JavaScript o F#.

• Per aprire la finestra Locals, durante il debug selezionare Debug>>Locals, oppure premere Alt+4.

Matrici e oggetti espandibili vengono visualizzati nelle finestre Auto e Variabili locali . Selezionare la freccia a sinistra di un nome di variabile per espandere la visualizzazione per visualizzare campi e proprietà. Di seguito è riportato un esempio di un oggetto System.IO.FileStream nella finestra delle variabili locali :

Un valore rosso nella finestra Variabili locali o Variabili automatiche indica che il valore è stato modificato dall'ultima valutazione. La modifica potrebbe derivare da una sessione di debug precedente o perché il valore è stato modificato nella finestra.

Il formato numerico predefinito nelle finestre del debugger è decimale. Per modificarlo in esadecimale, fare clic con il pulsante destro del mouse nella finestra Locali o Automatiche e selezionare Visualizzazione esadecimale. Questa modifica influisce su tutte le finestre del debugger.

Modificare i valori delle variabili nella finestra Auto o Variabili locali

Per modificare i valori della maggior parte delle variabili nelle finestre Autos o Locals, fare doppio clic sul valore e immettere il nuovo valore.

È possibile immettere un'espressione per un valore, ad esempio a + b. Il debugger accetta espressioni di linguaggio più valide.

Nel codice C++ nativo potrebbe essere necessario qualificare il contesto di un nome di variabile. Per altre informazioni, vedere operatore Context (C++).

Cautela

Assicurarsi di comprendere le conseguenze prima di modificare i valori e le espressioni. Alcuni possibili problemi sono:

• La valutazione di alcune espressioni può modificare il valore di una variabile o influire in altro modo sullo stato del programma. Ad esempio, la valutazione di var1 = ++var2 modifica il valore di var1 e var2. Si dice che queste espressioni abbiano effetti collaterali . Gli effetti collaterali possono causare risultati imprevisti se non si è a conoscenza di loro.

• La modifica di valori a virgola mobile può comportare piccole imprecisioni a causa della conversione decimale-binaria di componenti frazionari. Anche una modifica apparentemente innocua può comportare modifiche ad alcuni dei bit nella variabile a virgola mobile.

Cercare nella finestra Variabili automatiche o Variabili locali

È possibile cercare parole chiave nelle colonne Nome, Valore e Tipo della finestra Auto o della finestra Variabili locali usando la barra di ricerca posta sopra ciascuna 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 le frecce sinistra e destra (MAIUSC+F3 e F3) per navigare tra le corrispondenze trovate.

Per rendere la ricerca più o meno completa, usare la lista a discesa Cerca più a fondo nella parte superiore della finestra Auto o Locali per selezionare il numero di livelli da esaminare negli elementi annidati.

Aggiungere le proprietà nella finestra Auto o Variabili locali

Nota

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

È possibile esaminare rapidamente gli oggetti in base alle loro proprietà nelle finestre Auto e Variabili locali con lo strumento Proprietà bloccabili. 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 messa in evidenza all'inizio dell'elenco delle proprietà dell'oggetto, e il nome e il valore della proprietà vengono mostrati 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 alternare i nomi delle proprietà e filtrare le proprietà non bloccate quando si visualizza l'elenco delle proprietà dell'oggetto nelle finestre Auto o Locali. È possibile accedere a ogni opzione selezionando i pulsanti nella barra degli strumenti sopra le finestre Auto o Variabili locali.

Modificare il contesto per la finestra Auto o Variabili locali

È possibile usare la barra degli strumenti Posizione di debug per selezionare una funzione, un thread o un processo desiderato, che modifica il contesto per le finestre Automatici e Variabili locali.

Per abilitare la barra degli strumenti percorso di debug, fare clic in una parte vuota dell'area della barra degli strumenti e selezionare percorso di debug dall'elenco a discesa oppure selezionare Visualizza barre degli strumenti>>Percorso di debug.

Impostare un punto di interruzione e avviare il debug. Quando viene raggiunto il punto di interruzione, l'esecuzione viene sospesa ed è possibile visualizzare la posizione nella barra degli strumenti Posizione di Debug.

Differenze del linguaggio nella finestra Auto (C#, C++, Visual Basic, Python)

Diversi linguaggi di codice visualizzano variabili diverse nella finestra Autos.

• In C# e Visual Basic, la finestra Auto visualizza qualsiasi variabile usata nella riga corrente o precedente. Ad esempio, nel codice C# o Visual Basic dichiarare le quattro variabili seguenti:

       public static void Main()
       {
          int a, b, c, d;
          a = 1;
          b = 2;
          c = 3;
          d = 4;
       }
  

  Impostare un punto di interruzione nella riga c = 3;e avviare il debugger. Quando l'esecuzione viene sospesa, la finestra Autos verrà visualizzata:

  

  Il valore di c è 0, perché la riga c = 3 non è ancora stata eseguita.

• In C++, nella finestra Autos vengono visualizzate le variabili usate in almeno tre righe prima della riga corrente in cui l'esecuzione è sospesa. Ad esempio, nel codice C++ dichiarare sei variabili:

       void main() {
           int a, b, c, d, e, f;
           a = 1;
           b = 2;
           c = 3;
           d = 4;
           e = 5;
           f = 6;
       }
  

  Impostare un punto di interruzione nella riga e = 5; ed eseguire il debugger. Quando l'esecuzione viene arrestata, la finestra Auto verrà visualizzata:

  

  La variabile e non è inizializzata perché la riga e = 5 non è ancora stata eseguita.

Visualizzare i valori restituiti nella finestra Auto

Nell'esempio seguente questo codice C# aggiunge i valori restituiti di due funzioni:

static void Main(string[] args)
{
    int a, b, c, d;
    a = 1;
    b = 2;
    c = 3;
    d = 4;
    int x = sumVars(a, b) + subtractVars(c, d);
}

private static int sumVars(int i, int j)
{
    return i + j;
}

private static int subtractVars(int i, int j)
{
    return j - i;
}

Per visualizzare i valori restituiti delle chiamate al metodo sumVars() e subtractVars() nella finestra Auto:

1. Impostare un punto di interruzione nella riga int x = sumVars(a, b) + subtractVars(c, d);.

2. Avviare il debug e, quando l'esecuzione viene sospesa in corrispondenza del punto di interruzione, selezionare Passa sopra o premere F10. Nella finestra di Auto verranno visualizzati i seguenti valori restituiti:

   

Aprire un visualizzatore per controllare le variabili

Durante il debug in Visual Studio, è possibile visualizzare stringhe di grandi dimensioni o oggetti complessi con visualizzatori predefiniti che semplificano l'ispezione dei dati. Per esempio:

• Il visualizzatore di stringhe mostra stringhe di testo, XML, HTML e JSON troppo lunghe per una descrizione dati o una finestra del debugger. Può anche aiutare a identificare stringhe malformate. Per altre informazioni, vedere Visualizzare stringhe in un visualizzatore di stringhe.
• I visualizzatori DataSet e IEnumerable mostrano oggetti raccolta .NET in un visualizzatore tabulare. Per altre informazioni, vedere visualizzatori tabulari in oggetti di Visual Studio).

I visualizzatori appaiono nelle finestre Autos, nei suggerimenti per dati e in altre finestre del debugger.

Nota

Se è necessario esaminare gli elementi dell'interfaccia utente XAML o WPF in un visualizzatore, consulta Controllare le proprietà XAML durante il debug o Come usare il visualizzatore albero WPF.

Per aprire un visualizzatore, è necessario essere in pausa durante il debug. Passare il puntatore del mouse su una variabile con un valore del visualizzatore supportato e selezionare l'icona della lente di ingrandimento .

Contenuto correlato

• Che cos'è il debug?
• tecniche e strumenti di debug
• Prima analisi del debug
• finestre del debugger