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.
Hai capito l'editor e hai creato del codice. Ora si vuole assicurarsi che il codice funzioni correttamente. In Visual Studio, come per la maggior parte degli IDE, esistono due fasi per eseguire il lavoro del codice: compilare il codice per intercettare e risolvere gli errori del progetto e del compilatore ed eseguire il codice per trovare errori di runtime e dinamici.
Compilare il codice
Esistono due tipi di base di configurazione della build: Debug e Release. La configurazione debug produce un eseguibile più lento e più grande che consente un'esperienza di debug in fase di esecuzione interattiva più completa. Il file eseguibile di debug non deve mai essere spedito. La configurazione release crea un eseguibile più veloce e ottimizzato appropriato per la spedizione (almeno dal punto di vista del compilatore). La configurazione di compilazione predefinita è Debug.
Il modo più semplice per compilare il progetto consiste nel premere F7, ma è anche possibile avviare la compilazione selezionando 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). Qui vengono visualizzati errori, avvisi e operazioni di compilazione. Se si verificano errori (o se sono presenti avvisi al di sopra di un livello 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).
Ci sono due finestre a schede nella finestra dei risultati sotto l'editor: la finestra Output , che contiene l'output del compilatore non elaborato (inclusi i messaggi di errore); e la finestra Elenco errori , che fornisce un elenco ordinabile e filtrabile di tutti gli errori e gli avvisi.
Quando la compilazione ha esito positivo, nella finestra Output vengono visualizzati risultati simili al seguente:
Esaminare l'elenco errori
A meno che non siano state apportate modifiche al codice compilato in precedenza, è probabile che si verifichi un errore. Se sei nuovo nella programmazione, probabilmente ne avrai molti. 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+D, 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.
È possibile configurare l'opzione Numeri di riga nel riquadroOpzioni> nella sezione Tutte le impostazioni>Lingue>predefinite>Generale.
È possibile configurare l'opzione Linee numeriche nella finestra di dialogo Strumenti>Opzioni nella sezione Editor di testo>Tutte le lingue>Generale.
Premere CTRL+G per passare rapidamente al numero di riga in cui si è verificato l'errore.
Visual Studio identifica questo errore con una linea ondulata rossa. Passare il puntatore del mouse su di esso per altri dettagli. Effettua la correzione e il problema svanisce, anche se potresti introdurre un nuovo errore con la correzione. Questa azione è denominata "regressione".
Esaminare l'elenco degli errori e risolvere tutti gli errori nel codice.
Esaminare gli errori in dettaglio
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 sugli errori dal menu di scelta rapida, oppure selezionare il valore del codice errore con collegamento ipertestuale nella colonna Codice nella colonna Elenco errori.
A seconda delle impostazioni, nel Web browser vengono visualizzati i risultati della ricerca per il codice di errore e il testo oppure viene visualizzata una scheda all'interno di Visual Studio e vengono visualizzati i risultati della ricerca Bing. I risultati provengono da molte origini diverse su Internet e potresti non trovare tutti utili.
Usare l'analisi del codice
Gli analizzatori del codice cercano problemi di codice comuni che possono causare errori di runtime o problemi nella gestione del codice.
Analisi del codice C# e Visual Basic
Visual Studio include un set predefinito di analizzatori della piattaforma del compilatore .NET 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 linea ondulata sotto il codice incriminato.
Analisi del codice C++
Per analizzare il codice C++, eseguire l'analisi statica del codice. Acquisisci l'abitudine di eseguire il programma dopo aver corretto gli errori evidenti che impediscono una compilazione corretta, e prenditi 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.
Premere ALT+F11 (o selezionare Analizza esegui>analisi del codice nella soluzione dal menu in alto) per avviare l'analisi statica del codice.
Eventuali avvisi nuovi o aggiornati vengono visualizzati nella scheda Elenco errori nella parte inferiore dell'IDE. Seleziona un avviso per passare direttamente a quel punto nel codice.
Usare azioni rapide per correggere o effettuare il refactoring del codice
Azioni rapide, disponibili dall'icona lampadina o cacciavite, consentono di effettuare 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 accedervi, fare clic con il pulsante destro del mouse su un interruttore di avviso e selezionare Azioni rapide e refactoring. In alternativa, quando il cursore si trova sulla linea con la linea ondulata colorata, premere CTRL+. oppure selezionare l'icona a forma di lampadina, di errore o di cacciavite visualizzate accanto al codice applicabile. 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 ovunque gli analizzatori di codice determinino la possibilità di correggere, effettuare il refactoring o migliorare il codice. Seleziona qualsiasi riga di codice, fai clic destro per aprire il menu di scelta rapida e scegli Azioni rapide e refactoring. Se sono disponibili opzioni di refactoring o miglioramento, vengono visualizzate. In caso contrario, il messaggio Nessuna azione rapida disponibile qui viene visualizzato nell'angolo inferiore sinistro dell'IDE.
Con l'esperienza, puoi rapidamente usare i tasti di direzione e Ctrl+. per individuare facilmente le opportunità di refactoring e pulire il tuo codice.
Eseguire la pulizia del 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 di codice vengono lette dal file
Eseguire il debug del codice in esecuzione
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 cambia mentre l'app è in esecuzione: la finestra Output viene sostituita, nella configurazione predefinita, da due nuove finestre a schede: la finestra Autos/Locals/Watch e la finestra Call Stack/Breakpoints/Exception Settings/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.
Arrestare l'app premendo MAIUSC+F5 o facendo 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 perfettamente e esattamente come previsto, congratulazioni! 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.
Impostare punti di interruzione semplici
I punti di interruzione sono la funzionalità di base e essenziale del 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 di punti di interruzione.
Impostare un punto di interruzione facendo clic sul margine lontano della riga in cui si desidera che si verifichi l'interruzione oppure premere F9 per impostare un punto di interruzione sulla riga di codice corrente. Quando si esegue il codice, viene sospeso (o interrotto) prima dell'esecuzione delle istruzioni per questa riga di codice.
Gli usi comuni per i punti di interruzione includono:
Per individuare l'origine di un arresto anomalo o di un programma non rispondente, disperdere punti di interruzione in tutto e intorno al codice della chiamata al metodo che si ritiene stia causando l'errore. Quando si esegue il codice nel debugger, rimuovi e poi reimposta i punti di interruzione uno vicino all'altro finché non trovi la riga di codice incriminata. 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 i punti di interruzione per il codice algoritmico in modo da poter esaminare i valori delle variabili e dei dati quando il programma si interrompe.
Se si scrive codice C o C++, usare i punti di interruzione per arrestare il codice in modo da poter esaminare i valori degli indirizzi (cercare NULL) e i conteggi dei riferimenti durante il debug per gli errori correlati alla memoria.
Per altre informazioni sull'uso dei punti di interruzione, vedere Usare punti di interruzione nel debugger di Visual Studio.
Esaminare il codice in fase di esecuzione
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 step per eseguire il codice nel debugger. Se il codice contrassegnato è una chiamata al metodo, è possibile eseguirne l'istruzione premendo F11. È anche possibile passare oltre 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).
Mentre il debugger è in pausa, è possibile esaminare le variabili e gli stack di chiamate per determinare cosa sta succedendo. I valori rientrano negli intervalli che ti aspetti di vedere? Le chiamate vengono effettuate nell'ordine giusto?
Passare il puntatore del mouse su una variabile per visualizzare il valore e i riferimenti correnti. Se viene visualizzato un valore non previsto, probabilmente si è verificato 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 CPU e della memoria dell'app nel tempo. Più avanti nello sviluppo di app, puoi usare questi strumenti per cercare un uso eccessivo della CPU o un'allocazione di memoria imprevista. Usalo con la finestra di controllo e i punti di interruzione per determinare cosa provoca un uso eccessivo imprevisto o un rilascio di risorse non effettuato. Per altre informazioni, vedere Prima di tutto gli strumenti di profilatura (C#, Visual Basic, C++, F#).
Eseguire i test delle unità
Gli unit test sono la prima linea di difesa contro i bug del codice perché, quando eseguiti correttamente, testano una singola "unità" di codice, in genere una singola funzione e sono più facili da eseguire il debug rispetto al programma completo. Visual Studio installa i framework di unit test Microsoft per codice gestito e nativo. Usare un framework di unit test per creare unit test, eseguirli e segnalare i risultati di questi test. Rieseguire unit test quando si apportano modifiche per verificare che il codice funzioni ancora correttamente. Con Visual Studio Enterprise Edition è possibile eseguire i test automaticamente dopo ogni compilazione.
Per iniziare, leggi Genera unit test per il test di fuzzing usando IntelliTest.
Per altre informazioni sugli unit test in Visual Studio e su come possono aiutare a creare codice di qualità migliore, vedere Nozioni di base sugli unit test.