Condividi tramite

Eseguire il debug solo del codice utente con Just My Code

  • Articolo

Just My Code è una funzionalità di debug di Visual Studio che esegue automaticamente passaggi sulle chiamate a sistema, framework e altro codice non utente. Nella finestra stack di chiamate, Just My Code comprime queste chiamate in frame [codice esterno].

Just My Code funziona in modo diverso nei progetti .NET e C++.

Abilitare o disabilitare Just My Code

Per la maggior parte dei linguaggi di programmazione, Just My Code è abilitato per impostazione predefinita.

  • Per abilitare o disabilitare Just My Code in Visual Studio, in Tools>Options (o Debug>Options) >Debugging>General, selezionare o deselezionare Enable Just My Code.

Screenshot di Abilita Just My Code nella finestra di dialogo Opzioni.

Screenshot di Abilita Just My Code nella finestra di dialogo Opzioni.

Nota

Enable Just My Code è un'impostazione globale applicabile a tutti i progetti di Visual Studio in tutti i linguaggi.

Debugging solo del mio codice

Durante una sessione di debug, la finestra moduli mostra i moduli di codice che il debugger considera come Codice personale (codice utente), insieme allo stato di caricamento dei simboli. Per altre informazioni, vedere Acquisire familiarità con il modo in cui il debugger si collega all'app.

Screenshot del codice utente nella finestra Moduli.

Screenshot del codice utente nella finestra Moduli.

Nella finestra stack di chiamate o attività , Just My Code comprime il codice non utente in un frame di codice in grigio etichettato [External Code].

Screenshot del codice esterno nella finestra Stack di chiamate.

Screenshot del codice esterno nella finestra 'Call Stack'.

Consiglio

Per aprire i moduli , Stack di chiamate, Attivitào la maggior parte delle altre finestre di debug, è necessario trovarsi in una sessione di debug. Durante il debug, in Debug>Windowsselezionare le finestre da aprire.

Per visualizzare il codice in una finestra ridotta [Codice esterno], fare clic con il pulsante destro del mouse nella finestra Call Stack o Attività e scegliere Visualizza codice esterno dal menu di scelta rapida. Le righe di codice esterne espanse sostituiscono il frame [Codice esterno] .

Screenshot di Mostra codice esterno nella finestra Stack di chiamate.

Screenshot della finestra Call Stack che mostra il codice esterno.

Nota

Mostra codice esterno è un'impostazione del profiler utente corrente che si applica a tutti i progetti in tutti i linguaggi aperti dall'utente.

Facendo doppio clic su una riga di codice esterna espansa nella finestra Stack di chiamate viene evidenziata la riga di codice chiamante in verde nel codice sorgente. Per le DLL o altri moduli non trovati o caricati, potrebbe aprirsi una pagina con simboli o sorgente non trovati.

A partire da Visual Studio 2022 versione 17.7, è possibile modificare automaticamente il codice .NET facendo doppio clic su codice esterno nella finestra Stack di chiamate. Per ulteriori informazioni, vedere Generazione del codice sorgente da assembly .NET durante il debug.

.NET Just My Code

Nei progetti .NET, Just My Code utilizza i file dei simboli (.pdb) e le ottimizzazioni del programma per classificare il codice come utente e non utente. Il debugger .NET considera i binari ottimizzati e i file .pdb non caricati come codice non utente.

Tre attributi del compilatore influiscono anche su ciò che il debugger .NET considera come codice utente:

Il debugger .NET considera che tutto l'altro codice sia codice utente.

Durante il debug di .NET:

  • Debug>Step Into (o F11) sui passi del codice non utente fino alla riga successiva del codice utente.
  • Debug>Passaggio fuori (o MAIUSC+F11) sul codice non utente passa alla riga successiva del codice utente.

Se non è presente altro codice utente, il debug continua fino al termine, raggiunge un altro punto di interruzione o genera un errore.

Se il debugger si interrompe nel codice non utente (ad esempio, quando si utilizza Debug>Interrompi tutto e si sospende nel codice non utente), viene visualizzata la finestra Nessuna origine. È quindi possibile usare un comando debug>passaggio per passare alla riga di codice utente successiva.

Se si verifica un'eccezione non gestita nel codice non utente, il debugger si interrompe nella riga di codice utente in cui è stata generata l'eccezione.

Se per l'eccezione vengono abilitate le eccezioni per la prima probabilità, la riga di codice utente chiamante viene evidenziata in verde nel codice sorgente. Nella finestra stack di chiamate viene visualizzata la cornice con annotazioni con etichetta [codice esterno].

C++ Just My Code

A partire da Visual Studio 2017 versione 15.8, è supportato anche Just My Code per il debugging passo-passo del codice. Questa funzionalità richiede anche l'uso dell'opzione del compilatore /JMC (Just my code debugging). L'opzione è abilitata per impostazione predefinita nei progetti C++. Per finestra di stack di chiamate e supporto dello stack di chiamate in Just My Code, l'opzione /JMC non è necessaria.

Per essere classificato come codice utente, il PDB per il file binario contenente il codice utente deve essere caricato dal debugger (usare la finestra moduli per controllare lo stato di caricamento).

Per quanto riguarda il comportamento dello stack di chiamate, ad esempio nella finestra Stack di Chiamate, Just My Code in C++ considera solo queste funzioni come codice non utente:

  • Funzioni con informazioni sull'origine rimosse nel file dei simboli.
  • Funzioni in cui i file di simboli indicano che non esiste alcun file di origine corrispondente allo stack frame.
  • Funzioni specificate nei file *.natjmc nella cartella %VsInstallDirectory%\Common7\Packages\Debugger\Visualizers.

Per il comportamento di esecuzione passo-passo del codice, Just My Code in C++ considera solo queste funzioni come codice non utente:

  • Funzioni per le quali il file PDB corrispondente non è stato caricato nel debugger.
  • Funzioni specificate nei file *.natjmc nella cartella \Common7\Packages\Debugger\Visualizers %VsInstallDirectory%.

Nota

Per il supporto delle istruzioni del codice in Just My Code, il codice C++ deve essere compilato usando i compilatori MSVC in Visual Studio 15.8 Preview 3 o versione successiva e l'opzione del compilatore /JMC deve essere abilitata (è abilitata per impostazione predefinita). Per altri dettagli, vedere Personalizzare lo stack di chiamate C++ e il comportamento di esecuzione del codice e questo articolo del blog . Per il codice compilato con un compilatore meno recente, i file .natstepfilter sono l'unico modo per personalizzare i passi nel codice, indipendente da Just My Code. Consultare Personalizzare il comportamento del passo C++.

Durante il debug C++, il codice non utente viene ignorato per impostazione predefinita. Durante il debug di C++:

  • Debug>Entra nel (o F11) salta il codice non utente o prosegue fino alla riga di codice utente successiva, se Entra nel è chiamato dal codice non utente.
  • Debug>Step Out (o Shift+F11) nel codice non utente esegue la riga successiva del codice utente (al di fuori della cornice dello stack corrente).

Se non è presente altro codice utente, il debug continua fino al termine, raggiunge un altro punto di interruzione o genera un errore.

Se il debugger si interrompe nel codice non utente (ad esempio, si usa Debug>Interrompi tutto e si mette in pausa nel codice non utente), l'esecuzione passo a passo continua nel codice non utente.

Se il debugger raggiunge un'eccezione, si arresta sull'eccezione, indipendentemente dal fatto che si tratti di codice utente o non utente. Opzioni non gestite dall'utente nella finestra di dialogo Impostazioni eccezioni vengono ignorate.

Personalizzare lo stack di chiamate C++ e il comportamento passo-passo del codice

Per i progetti C++, è possibile specificare i moduli, i file di origine e le funzioni della finestra stack di chiamate considera come codice non utente specificandoli in file *.natjmc. Questa personalizzazione si applica anche al passo a passo del codice se si utilizza il compilatore più recente (vedere C++ Just My Code).

  • Per specificare il codice non utente per tutti gli utenti del computer di Visual Studio, aggiungere il file natjmc alla cartella %VsInstallDirectory%\Common7\Packages\Debugger\Visualizers.
  • Per specificare il codice non utente per un singolo utente, aggiungere il file .natjmc alla cartella %USERPROFILE%\Documenti personali\<versione di Visual Studio>\Visualizers.

Un file natjmc è un file XML con questa sintassi:

<?xml version="1.0" encoding="utf-8"?>
<NonUserCode xmlns="http://schemas.microsoft.com/vstudio/debugger/jmc/2015">

  <!-- Modules -->
  <Module Name="ModuleSpec" />
  <Module Name="ModuleSpec" Company="CompanyName" />

  <!-- Files -->
  <File Name="FileSpec"/>

  <!-- Functions -->
  <Function Name="FunctionSpec" />
  <Function Name="FunctionSpec" Module ="ModuleSpec" />
  <Function Name="FunctionSpec" Module ="ModuleSpec" ExceptionImplementation="true" />

</NonUserCode>

attributi dell'elemento module

Attributo Descrizione
Name Obbligatorio. Percorso completo del modulo o dei moduli. È possibile utilizzare i caratteri jolly di Windows ? (zero o un carattere), e * (zero o più caratteri). Per esempio

<Module Name="?:\3rdParty\UtilLibs\*" />

indica al debugger di considerare tutti i moduli in \3rdParty\UtilLibs in qualsiasi unità come codice esterno.
Company Opzionale. Nome della società che pubblica il modulo incorporato nel file eseguibile. È possibile usare questo attributo per evitare ambiguità tra i moduli.

attributi dell'elemento File

Attributo Descrizione
Name Obbligatorio. Percorso completo del file o dei file di origine da considerare come codice esterno. È possibile usare i caratteri jolly di Windows ? e * quando si specifica il percorso.

Attributi dell'elemento Function

Attributo Descrizione
Name Obbligatorio. Nome completo della funzione da considerare come codice esterno. Puoi usare i caratteri jolly di Windows ? e * quando specifichi il percorso.
Module Opzionale. Nome o percorso completo del modulo che contiene la funzione. È possibile usare questo attributo per disambiguare le funzioni con lo stesso nome.
ExceptionImplementation Se impostato su true, lo stack di chiamate visualizza la funzione che ha generato l'eccezione anziché questa funzione.

Personalizzare il comportamento di esecuzione delle istruzioni C++ indipendentemente dall'impostazione Just My Code

Nei progetti C++ è possibile specificare le funzioni da saltare elencandole come funzioni NoStepInto nei file *.natstepfilter. Le funzioni elencate in file *.natstepfilter non dipendono dalle impostazioni Just My Code. Una funzione NoStepInto indica al debugger di saltare la funzione, persino se questa chiama alcune funzioni StepInto o altro codice utente. A differenza delle funzioni elencate in .natjmc, il debugger eseguirà l'istruzione nella prima riga di codice utente all'interno della funzione NoStepInto.

  • Per specificare il codice non utente per tutti gli utenti di Visual Studio locali, aggiungere il file natstepfilter alla cartella %VsInstallDirectory%\Common7\Packages\Debugger\Visualizers.
  • Per specificare il codice non utente per un singolo utente, aggiungere il file natstepfilter alla cartella %USERPROFILE%\I miei documenti\<versione di Visual Studio>\Visualizers.

Nota

Alcune estensioni di terze parti possono disabilitare la funzionalità del filtro passo-nat.

Un file .natstepfilter è un file XML con questa sintassi:

<?xml version="1.0" encoding="utf-8"?>
<StepFilter xmlns="http://schemas.microsoft.com/vstudio/debugger/natstepfilter/2010">
    <Function>
        <Name>FunctionSpec</Name>
        <Action>StepAction</Action>
    </Function>
    <Function>
        <Name>FunctionSpec</Name>
        <Module>ModuleSpec</Module>
        <Action>StepAction</Action>
    </Function>
</StepFilter>
Elemento Descrizione
Function Obbligatorio. Specifica una o più funzioni come funzioni non utente.
Name Obbligatorio. Espressione regolare formattata ECMA-262 che specifica il nome completo della funzione da far corrispondere. Per esempio:

<Name>MyNS::MyClass::.*</Name>

indica al debugger che tutti i metodi in MyNS::MyClass devono essere considerati codice non utente. La corrispondenza fa distinzione tra maiuscole e minuscole.
Module Opzionale. Espressione regolare formattata ECMA-262 che specifica il percorso completo del modulo contenente la funzione. La corrispondenza non fa distinzione tra maiuscole e minuscole.
Action Obbligatorio. Uno di questi valori con distinzione tra maiuscole e minuscole:

NoStepInto : indica al debugger di saltare la funzione.
StepInto: indica al debugger di entrare nella funzione, annullando qualsiasi altro NoStepInto per la funzione corrispondente.

Altre informazioni sui file .natstepfilter e .natjmc

  • A partire da Visual Studio 2022 versione 17.6, è possibile aggiungere file natjmc e natstepfilter file direttamente alla soluzione o al progetto.

  • Gli errori di sintassi nei .natstepfilter e file natjmc non vengono segnalati nella finestra Output del debugger.

  • A differenza di file natvis, file natstepfilter e file natjmc non vengono ricaricati a caldo. Questi file vengono invece ricaricati all'inizio della sessione di debug.

  • Per le funzioni modello, l'uso di &lt;.*&gt; o &lt;.* nel nome può essere utile.

JavaScript Solo Il Mio Codice

Per progetti con estensione .esproj in Visual Studio 2022, Visual Studio Code usa un file launch.json per configurare e personalizzare il debugger. launch.json è un file di configurazione del debugger.

Visual Studio collega il debugger solo al codice utente. Per progetti di con estensione esproj, è possibile configurare il codice utente( ovvero impostazioni just my code) in Visual Studio usando l'impostazione skipFiles in launch.json. Questa impostazione funziona come le impostazioni di launch.json in VS Code. Per ulteriori informazioni su skipFiles, vedere Ignorare il Codice Poco Interessante.