Condividi tramite

Eseguire il debug utilizzando il Just-In-Time Debugger in Visual Studio

La funzionalità di debug Just-In-Time può avviare automaticamente Visual Studio quando un'app in esecuzione al di fuori di Visual Studio si verifica un errore o si arresta. Con just-In-Time debug, è possibile testare le app all'esterno di Visual Studio e aprire Visual Studio per avviare il debug quando si verifica un problema.

Just-In-Time debug funziona per le app desktop di Windows. Non funziona per le app di Windows universali o per il codice gestito ospitato in un'applicazione nativa, ad esempio i visualizzatori.

Suggerimento

Per interrompere la visualizzazione della finestra di dialogo Just-In-Time Debugger, ma non è installato Visual Studio, vedere Disabilitare just-In-Time Debugger. Se Visual Studio è stato installato, potrebbe essere necessario disabilitare Just-In-Time debug dal Registro di sistema di Windows.

Abilitare o disabilitare il debug Just-In-Time in Visual Studio

Quando si usa il debugger Just-In-Time in Visual Studio, le opzioni di configurazione per il debugger sono accessibili dai menu Opzioni strumenti> oOpzionidi debug>. Il debugger Just-In-Time è disponibile nella sezioneDebug e test dei > del programma di installazione.

Annotazioni

Per abilitare o disabilitare il debug just-In-Time, è necessario eseguire Visual Studio come amministratore. L'abilitazione o la disabilitazione di Just-In-Time il debug imposta una chiave del Registro di sistema e potrebbero essere necessari privilegi di amministratore per modificare la chiave. Per aprire Visual Studio come amministratore, fare clic con il pulsante destro del mouse sull'app di Visual Studio e scegliere Esegui come amministratore.

Per abilitare o disabilitare il debug just-In-Time:

  1. Nel riquadro Opzioni strumenti> espandere la sezione Tutte le impostazioni>>.

  2. Nel riquadro destro selezionare il collegamento Configura il debugging Just-In-Time.

    Schermata che mostra come configurare il debugging Just-In-Time in Visual Studio.

  3. Nella finestra di dialogo Opzioni del debugger di Visual Studio configurare l'opzione Abilita il debug Just-In-Time per questi tipi di codice. Selezionare i tipi di codice di cui eseguire il debug Just-In-Time: gestito (.NET Framework) o nativo.

  4. Seleziona OK.

  1. Nella finestra di dialogo Strumenti>Opzioni, espandere la sezione Debugging>Just-In-Time.

  2. Nella casella Enable Just-In-Time debugging for these types of code (Abilita il debug Just-In-Time per questi tipi di codice), selezionare i tipi di codice desiderati per il debug Just-In-Time: Gestito, Nativo e/o Script.

    Abilitare o disabilitare il debug JIT

  3. Seleziona OK.

Se si abilita il debugger Just-In-Time, ma non si apre quando un'app si arresta in modo anomalo o si verificano errori, vedere Risolvere i problemi relativi al debug just-In-Time.

Disabilita just-In-Time debug dal Registro di sistema di Windows

Just-In-Time debug potrebbe essere ancora abilitato anche se Visual Studio non è più installato nel computer. Se Visual Studio non è più installato, puoi disabilitare Just-In-Time debug modificando il Registro di sistema di Windows.

Per disabilitare il debug just-In-Time modificando il Registro di sistema:

  1. Dal menu Start di Windows eseguire l'editor del Registro di sistema (regedit.exe).

  2. Nella finestra Editor del Registro di sistema individuare ed eliminare le voci del Registro di sistema seguenti, se presenti:

    • HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\Windows NT\CurrentVersion\AeDebug\Debugger

    • HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\.NETFramework\DbgManagedDebugger

    Chiave del Registro di sistema JIT

  3. Eliminare anche le seguenti voci del Registro di sistema, se presenti:

    • HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\AeDebug\Debugger

    • HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\.NETFramework\DbgManagedDebugger

    Assicurarsi di non eliminare o modificare altre chiavi del Registro di sistema.

  4. Chiudere la finestra Dell'editor del Registro di sistema .

Abilitare il debug Just-In-Time di un modulo Windows

Per impostazione predefinita, le app di Windows Form hanno un gestore eccezioni di primo livello che consente all'app di continuare l'esecuzione se può essere ripristinata. Se un'app Windows Form genera un'eccezione non gestita, viene visualizzata la finestra di dialogo seguente:

Eccezione Windows Form non gestita

Per abilitare just-In-Time debug anziché la gestione degli errori standard di Windows Form, aggiungere queste impostazioni:

  • Nella sezione system.windows.forms del file machine.config o del file <nome dell'app>.exe.config, impostare il jitDebugging valore su true:

    <configuration>
    <system.windows.forms jitDebugging="true" />
</configuration>

  • In un'applicazione C++ Windows Form, imposta DebuggableAttribute su true anche in un file .config o nel tuo codice. Se si esegue la compilazione con /Zi e senza /Og, il compilatore imposta automaticamente questo attributo. Se vuoi eseguire il debug di una build di versione non ottimizzata, devi tuttavia impostare DebuggableAttribute aggiungendo la riga seguente nel file AssemblyInfo.cpp dell'app:

    [assembly:System::Diagnostics::DebuggableAttribute(true, true)];

    Per altre informazioni, vedere DebuggableAttribute.

Usare il debugging Just-In-Time

Questo esempio illustra il debug Just-In-Time quando un'applicazione genera un errore.

  • Per seguire questa procedura, è necessario che Visual Studio sia installato. Se non hai Visual Studio, puoi scaricare gratuitamente Visual Studio Community Edition.

  • Assicurarsi che il debug just-In-Time sia abilitato configurando l'opzione Abilita just-In-Time debug per questi tipi di codice in Opzioni strumenti>.

Per questo esempio si crea un'app console C# in Visual Studio che genera un NullReferenceException.

  1. In Visual Studio creare un'app console C# (File>New>Project>Visual C#>Console Application) denominata ThrowsNullException. Per altre informazioni sulla creazione di progetti in Visual Studio, vedere Procedura dettagliata: Creare una semplice applicazione.

  2. Quando il progetto viene aperto in Visual Studio, aprire il file Program.cs . Sostituire il metodo Main() con il codice seguente, che stampa una riga nella console e quindi genera un'eccezione NullReferenceException:

    static void Main(string[] args)
{
    Console.WriteLine("we will now throw a NullReferenceException");
    throw new NullReferenceException("this is the exception thrown by the console app");
}

  3. Per compilare la soluzione, scegliere la configurazione Debug (impostazione predefinita) o Release e quindi selezionare Compila> soluzione.

    • Per l'esperienza di debug completa, selezionare la configurazione debug .

    • Se si seleziona la configurazione Rilascio, è necessario disattivare "Just My Code" per il funzionamento di questa procedura.

      Nel riquadro Opzioni strumenti> espandere la sezione Tutte le impostazioni>> e deselezionare la casella di controllo Abilita Just My Code.

      Nella finestra di dialogo Opzioni strumenti> espandere la sezione Debug> e deselezionare la casella di controllo Abilita Just My Code.

      Quando si deseleziona questa opzione, l'opzione Avvisa se non è presente codice utente all'avvio del debug (solo gestito) viene disabilitata automaticamente.

    Per altre informazioni sulle configurazioni di compilazione, vedere Informazioni sulle configurazioni di compilazione.

  4. Aprire l'app compilata ThrowsNullException.exe nella cartella del progetto C# (...\ThrowsNullException\ThrowsNullException\bin\Debug o ...\ThrowsNullException\ThrowsNullException\bin\Release).

    Verrà visualizzata la finestra di comando seguente:

    Screenshot della console per ThrowsNullException.exe, che solleva un'eccezione di riferimento null non gestita (System.NullReferenceException).

  5. Verrà visualizzata la finestra di dialogo Scegli Just-In-Time Debugger.

    Screenshot della finestra di dialogo Scegli just-In-Time Debugger, visualizzata dopo la visualizzazione dell'eccezione nella finestra della console ThrowsNullException.exe.

    In Debugger disponibili selezionare Nuova istanza della <versione/edizione> di Visual Studio preferita, se non è già selezionata.

  6. Seleziona OK.

    Il progetto ThrowsNullException si apre in una nuova istanza di Visual Studio, con l'esecuzione interrotta alla riga che ha causato l'eccezione:

    Screenshot del progetto ThrowsNullException in Visual Studio, con l'evidenziazione della riga di codice sorgente che ha generato l'eccezione.

A questo punto è possibile avviare il debug. Se si esegue il debug di un'app reale, è necessario scoprire perché il codice genera l'eccezione.

Attenzione

Se l'app contiene codice non attendibile, viene visualizzata una finestra di dialogo di avviso di sicurezza che consente di decidere se procedere con il debug. Prima di continuare il debug, decidere se considerare attendibile il codice. Il codice è stato scritto manualmente? Se l'applicazione è in esecuzione in un computer remoto, si riconosce il nome del processo? Se l'app è in esecuzione in locale, prendere in considerazione la possibilità di eseguire codice dannoso nel computer. Se si decide che il codice è attendibile, selezionare OK. In caso contrario, selezionare Annulla.

Risolvere i problemi di Just-In-Time debugging

Se il debug Just-In-Time non viene avviato quando un'app va in crash, anche se è abilitato in Visual Studio:

  • Un problema noto di Windows potrebbe causare l'esito negativo del debugger just-In-Time.

    La correzione consiste nell'aggiungere un valore DWORDAuto, con dati valorepari a 1, alle seguenti chiavi del Registro di sistema:

    • HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\AeDebug

    • (Per le app a 32 bit in computer a 64 bit) HKEY_LOCAL_MACHINE\Software\WOW6432Node\Microsoft\Windows NT\CurrentVersion\AeDebug

  • Windows Error Reporting potrebbe prendere il controllo della gestione degli errori sul computer.

    Per risolvere questo problema, usare l'editor del Registro di sistema per aggiungere un valore DWORD di Disabled, con Valore dati pari a 1, alle chiavi del Registro di sistema seguenti:

    • HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\Windows Error Reporting

    • (Per le app a 32 bit su macchine a 64 bit) HKEY_LOCAL_MACHINE\Software\WOW6432Node\Microsoft\Windows\Windows Error Reporting

    Per altre informazioni, vedere Impostazioni WER.

Durante il debug just-In-Time potrebbero essere visualizzati i messaggi di errore seguenti:

  • Impossibile connettersi al processo di arresto anomalo del sistema. Il programma specificato non è un programma Windows o MS-DOS.

    Il debugger ha tentato di connettersi a un processo in esecuzione con un altro utente.

    Per risolvere questo problema, in Visual Studio aprire Debug>Collega a processo (o premere CTRL + ALT + P) e trovare il processo di cui si vuole eseguire il debug nell'elenco Processi disponibili . Se non si conosce il nome del processo, trovare l'ID processo nella finestra di dialogo Just-In-Time Debugger di Visual Studio . Selezionare il processo nell'elenco Processi disponibili e selezionare Connetti. Selezionare No per chiudere la finestra di dialogo Just-In-Time debugger.

  • Impossibile avviare il debugger perché nessun utente ha effettuato l'accesso.

    Non è presente alcun utente connesso alla console, quindi non è disponibile alcuna sessione utente per visualizzare la finestra di dialogo Just-In-Time debug.

    Per risolvere il problema, accedere al computer.

  • Classe non registrata.

    Il debugger ha tentato di creare una classe COM non registrata, probabilmente a causa di un problema di installazione.

    Per risolvere il problema, usare il programma di installazione di Visual Studio per reinstallare o ripristinare l'installazione di Visual Studio.

Contenuti correlati

  • Last updated on