Nota
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare ad accedere o modificare le directory.
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare a modificare le directory.
Visual Studio include un potente set integrato di strumenti di compilazione e debug del progetto. Questo articolo descrive in che modo Visual Studio consente di trovare problemi nel codice usando l'output di compilazione, l'analisi del codice, gli strumenti di debug e gli unit test.
Si è già acquisita una certa familiarità con l'editor ed è stato creato del codice. Ora si vuole avere la sicurezza che il codice funzioni correttamente. In Visual Studio, come nella maggior parte degli IDE, per garantire il funzionamento del codice sono necessari due passaggi: la compilazione del codice per rilevare e risolvere gli errori relativi al progetto e al compilatore e l'esecuzione del codice per individuare gli errori dinamici e di run-time.
Sono disponibili due tipi di base per la configurazione della build: Debug e Release. La configurazione di tipo Debug produce un file eseguibile più lento e di dimensioni maggiori che offre un'esperienza di debug del runtime interattiva più completa. Il file eseguibile di Debug non deve essere mai distribuito. La configurazione di tipo Release compila un file eseguibile più veloce e ottimizzato, adatto alla distribuzione (almeno dal punto di vista del compilatore). La configurazione predefinita della build è Debug.
Il modo più semplice per compilare il progetto è premere F7, ma è anche possibile avviare la compilazione selezionando Compila>Compila soluzione dal menu principale.
È possibile osservare il processo di compilazione nella finestra Output nella parte inferiore dell'interfaccia utente di Visual Studio (interfaccia utente). dove vengono visualizzati gli eventuali errori, avvisi e operazioni di compilazione. In caso di errori, o se vengono rilevati avvisi di livello superiore a quello configurato, la compilazione ha esito negativo. È possibile selezionare gli errori e gli avvisi da passare alla riga in cui si sono verificati. Ricompilare il progetto premendo di nuovo F7, per ricompilare solo i file con errori, o CTRL+ALT+F7, per una ricompilazione pulita e completa.
Nella finestra dei risultati sotto l'editor vengono visualizzate due finestre a schede: la finestra Output che contiene l'output del compilatore non elaborato (compresi i messaggi di errore) e la finestra Elenco errori che visualizza un elenco ordinabile e filtrabile di tutti gli errori e gli avvisi.
Se la compilazione viene completata correttamente, nella finestra Output vengono visualizzati risultati simili ai seguenti:
A meno che non siano state apportate modifiche al codice compilato in precedenza e correttamente, è probabile che si sia verificato un errore. Se non si ha familiarità con la codifica, gli errori potrebbero essere numerosi. Gli errori sono talvolta evidenti, ad esempio un semplice errore di sintassi o un nome di variabile non corretto, e a volte sono difficili da comprendere, con solo un codice criptico per guidare l'utente. Per una visualizzazione più chiara dei problemi, passare alla parte inferiore della finestra Output di compilazione e selezionare la scheda Elenco errori. Questa azione consente di visualizzare in modo più organizzato gli errori e gli avvisi per il progetto e offre anche alcune opzioni aggiuntive.
Selezionare la riga di errore nella finestra Elenco errori per passare alla riga in cui si verifica l'errore. (In alternativa, attivare i numeri di riga premendo CTRL+Q, digitando numeri di riga e quindi scegliendo Attiva o disattiva i numeri di riga dai risultati. Questa azione è il modo più rapido per accedere alla finestra di dialogo Opzioni in cui è possibile attivare i numeri di riga.
Per passare rapidamente al numero di riga in cui si è verificato l'errore, premere CTRL+G.
Visual Studio identifica questo errore con un carattere di sottolineatura "ondulato" rosso. Passare il puntatore del mouse su di esso per altri dettagli. Apportare la correzione e rimuoverla, anche se è possibile introdurre un nuovo errore con la correzione. Questa azione è denominata "regressione".
Scorrere l'elenco degli errori e risolvere tutti gli errori nel codice.
Molti errori potrebbero non avere senso per l'utente, espresso come sono in termini del compilatore. In questi casi, potrebbero essere necessarie informazioni aggiuntive. Nella finestra Elenco errori è possibile eseguire una ricerca automatica di Bing per altre informazioni sull'errore o sull'avviso. Fare clic con il pulsante destro del mouse sulla riga corrispondente e scegliere Mostra guida errori dal menu di scelta rapida oppure selezionare il valore del codice errore con collegamento ipertestuale nella colonna Codice dell'elenco errori.
A seconda delle impostazioni, il Web browser visualizza i risultati della ricerca per il testo e il codice di errore o si apre una scheda in Visual Studio contenente i risultati della ricerca in Bing. I risultati provengono da molte origini diverse su Internet e potresti non trovare tutti utili.
Gli analizzatori di codice cercano i problemi di codice comuni che possono causare errori di run-time o problemi nella gestione del codice.
Visual Studio include un set predefinito di analizzatori .NET Compiler Platform che esaminano il codice C# e Visual Basic durante la digitazione. È possibile installare più analizzatori come estensione di Visual Studio o come pacchetto NuGet. Se vengono rilevate violazioni delle regole, vengono segnalate sia nell'elenco errori che nell'editor di codice come interruttore sotto il codice che causa l'errore.
Per analizzare il codice C++, eseguire l'analisi del codice statico. Acquisire l'abitudine di eseguirla dopo aver pulito gli errori evidenti che impediscono una compilazione corretta e richiedere del tempo per risolvere gli avvisi che potrebbe produrre. È possibile risparmiare alcuni mal di testa lungo la strada, e si potrebbero imparare alcune tecniche di stile del codice.
Per avviare l'analisi del codice statico, premere ALT+F11 o selezionare Analizza>Esegui analisi del codice sulla soluzione dal menu principale.
Eventuali avvisi nuovi o aggiornati vengono visualizzati nella scheda Elenco errori nella parte inferiore dell'IDE. Selezionare un avviso per passare al codice.
Le Azioni rapide, disponibili dall'icona a forma di lampadina o di cacciavite, consentono di eseguire il refactoring del codice inline. Si tratta di un modo semplice per correggere gli avvisi comuni in modo rapido ed efficace nel codice C#, C++e Visual Basic. Per accedere a questa nuova funzionalità, fare clic con il pulsante destro del mouse sulla linea ondulata sotto un avviso e scegliere Azioni rapide e refactoring. In alternativa, quando il cursore si trova sulla linea con la sottolineatura ondulata colorata, premere CTRL+ oppure selezionare la lampadina, la lampadina di errore o l'icona del cacciavite nel margine. Visual Studio visualizza quindi un elenco di possibili correzioni o refactoring che è possibile applicare a tale riga di codice.
Le Azioni rapide possono essere usate in tutti i casi in cui gli analizzatori di codice individuano la possibilità di correggere, eseguire il refactoring o migliorare il codice. Selezionare in qualsiasi riga di codice, fare clic con il pulsante destro del mouse per aprire il menu di scelta rapida e scegliere Azioni rapide e refactoring. Se sono disponibili opzioni di refactoring o miglioramento, vengono visualizzate. In caso contrario, viene visualizzato il messaggio Azioni rapide non disponibili in questo punto nell'angolo inferiore sinistro dell'IDE.
Con l'esperienza, è possibile usare rapidamente i tasti di direzione e CTRL+. per verificare la facilità di refactoring delle opportunità e pulire il codice.
Visual Studio offre la formattazione su richiesta del file di codice C#, incluse le preferenze di stile del codice, tramite il pulsante Pulizia codice nella parte inferiore dell'editor.
Oltre a formattare il file per spazi, rientri e così via, Pulizia codice applica anche un set di convenzioni di stile di codice definite dall'utente. Le preferenze per ogni stile del codice vengono lette dal file EditorConfig, se ce n'è uno per il progetto, o dalle impostazioni di stile del codice nella finestra di dialogo Opzioni.
Dopo aver compilato correttamente il codice ed eseguito un po' di pulizia, eseguirlo premendo F5 o selezionando Debug>Avvia debug. Questa azione avvia l'app in un ambiente di debug in modo da poterne osservare in dettaglio il comportamento. L'IDE di Visual Studio viene modificato mentre l'applicazione è in esecuzione. La finestra Output viene sostituita da due nuove finestre a schede (nella configurazione predefinita della finestra): Auto/Variabili locali/Espressione di controllo e Stack di chiamate/Punti di interruzione/Impostazioni eccezione/Output. Queste finestre hanno più schede che consentono di esaminare e valutare le variabili, i thread, gli stack di chiamate e altri comportamenti dell'app durante l'esecuzione.
Per arrestare l'app, premere MAIUSC+F5 o fare clic sul pulsante Arresta. In alternativa, è sufficiente chiudere la finestra principale dell'app (o la finestra di dialogo della riga di comando).
Se il codice è stato eseguito senza errori ed esattamente come previsto, complimenti! Tuttavia, a volte il codice potrebbe smettere di rispondere o arrestarsi in modo anomalo o ottenere risultati strani. In tal caso, è consigliabile provare a trovare l'origine di tali problemi e correggere i bug.
I punti di interruzione rappresentano la funzionalità di base essenziale per un debug affidabile. Un punto di interruzione indica dove Visual Studio deve sospendere il codice in esecuzione in modo da poter esaminare i valori delle variabili o il comportamento della memoria o se viene eseguito un ramo di codice. Non è necessario ricompilare un progetto dopo l'impostazione e la rimozione dei punti di interruzione.
Impostare un punto di interruzione facendo clic sul margine più esterno della riga in cui si vuole inserire l'interruzione oppure premere F9 per impostare un punto di interruzione nella riga di codice corrente. Quando si esegue il codice, viene sospeso (o interrotto) prima dell'esecuzione delle istruzioni per questa riga di codice.
Di seguito sono riportati alcuni usi comuni dei punti di interruzione:
Per restringere l'origine di un programma di arresto anomalo o non risponde, i punti di interruzione a dispersione in tutto e intorno al codice della chiamata al metodo che si ritiene stia causando l'errore. Durante l'esecuzione del codice nel debugger, rimuovere e reimpostare i punti di interruzione fino a individuare la riga di codice interessata. Vedere la sezione successiva per informazioni su come eseguire il codice nel debugger.
Quando si introduce un nuovo codice, impostare un punto di interruzione all'inizio di esso ed eseguire il codice per assicurarsi che funzioni come previsto.
Se è stato implementato un comportamento complesso, impostare punti di interruzione per il codice algoritmico affinché sia possibile esaminare i valori delle variabili e i dati quando il programma si interrompe.
Se si scrive codice C o C++, usare i punti di interruzione per arrestare il codice affinché sia possibile esaminare i valori di indirizzo (cercare NULL) e conteggi riferimenti durante il debug degli errori correlati alla memoria.
Per altre informazioni sull'uso dei punti di interruzione, vedere Usare punti di interruzione nel debugger di Visual Studio.
Quando il codice in esecuzione raggiunge un punto di interruzione e si sospende, la riga di codice contrassegnata in giallo (l'istruzione corrente) non è ancora stata eseguita. A questo punto, è possibile eseguire l'istruzione corrente e quindi esaminare i valori modificati. È possibile usare diversi comandi di esecuzione per eseguire il codice nel debugger. Se il codice contrassegnato è una chiamata a un metodo, è possibile eseguire le istruzioni premendo F11. È anche possibile eseguire l'istruzione/la routine per la riga di codice premendo F10. Per altri comandi e informazioni dettagliate su come eseguire il codice, vedere Esplorare il codice usando il debugger.
Nella figura precedente è possibile avanzare l'istruzione del debugger premendo F10 o F11 (poiché non è presente alcuna chiamata al metodo, entrambi i comandi hanno lo stesso risultato).
Quando il debugger viene sospeso, è possibile esaminare le variabili e gli stack di chiamate per individuare il problema. I valori sono compresi negli intervalli previsti? L'ordine con cui si stanno eseguendo le chiamate è corretto?
Passare il mouse su una variabile per visualizzarne il valore corrente e i riferimenti. Se viene visualizzato un valore non previsto, è probabile che ci sia un bug nel codice precedente o chiamante. Per altre informazioni, vedere Prima di tutto il debugger di Visual Studio.
Visual Studio visualizza anche la finestra Strumenti di diagnostica, in cui è possibile osservare l'utilizzo della memoria e della CPU dell'app nel corso del tempo. Durante lo sviluppo dell'app, è possibile usare questi strumenti per individuare l'utilizzo intenso della CPU imprevisto o l'allocazione della memoria. Usarlo con la finestra Espressioni di controllo e i punti di interruzione per determinare cosa causa un utilizzo eccessivo imprevisto o risorse non rilasciate. Per altre informazioni, vedere Prima di tutto gli strumenti di profilatura (C#, Visual Basic, C++, F#).
Gli unit test sono il primo elemento di difesa contro i bug nel codice perché, se eseguiti correttamente, testano una singola "unità" di codice, in genere una singola funzione, ed è più semplice eseguirne il debug rispetto all'intero programma. Visual Studio installa i framework degli unit test di Microsoft sia per il codice gestito e che per quello nativo. Usare un framework di testing unità per creare unit test, eseguirli e riportare i risultati dei test. Eseguire nuovamente gli unit test quando si apportano modifiche per verificare che il codice funzioni ancora correttamente. Con Visual Studio Enterprise è possibile eseguire automaticamente i test dopo ogni compilazione.
Per iniziare, leggere Generare unit test per i test fuzz usando IntelliTest.
Per altre informazioni sugli unit test in Visual Studio e su come usarli per creare codice di qualità migliore, vedere Unit Test Basics (Nozioni di base sugli unit test).