Eseguire il debug solo del codice utente con Just My Code

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 Strumenti>Opzioni (o Opzioni di debug>)> Debug>generale selezionare o deselezionare Abilita Just My Code.

Nota

Abilita Just My Code è un'impostazione globale che si applica a tutti i progetti di Visual Studio in tutti i linguaggi.

debug Just My Code

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

Nella finestra Stack di chiamate o attività Just My Code comprime il codice non utente in una cornice di codice con annotazioni disattivate con [External Code]etichetta .

Suggerimento

Per aprire 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>Windows selezionare le finestre da aprire.

Per visualizzare il codice in un frame [Codice esterno] compresso, fare clic con il pulsante destro del mouse nella finestra Stack di chiamate o attività e scegliere Mostra codice esterno dal menu di scelta rapida. Le righe di codice esterne espanse sostituiscono il frame [Codice esterno].

Nota

Mostra codice esterno è un'impostazione del profiler utente corrente che si applica a tutti i progetti in tutte le lingue aperte dall'utente.

Facendo doppio clic su una riga di codice esterno espansa nella finestra Stack di chiamate, la riga del codice chiamante viene evidenziata in verde nel codice sorgente. Per le DLL o altri moduli non trovati o caricati, è possibile aprire un simbolo o una pagina di origine non trovata.

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 altre informazioni, vedere Generare codice sorgente da assembly .NET durante il debug.

.NET Just My Code

Nei progetti .NET Just My Code usa file di simboli (con estensione pdb) e ottimizzazioni del programma per classificare il codice utente e non utente. Il debugger .NET considera file binari ottimizzati e file con estensione pdb non caricati come codice non utente.

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

• DebuggerNonUserCodeAttribute indica al debugger che il codice a cui viene applicato non è codice utente.
• DebuggerHiddenAttribute nasconde il codice al debugger, anche se Just My Code è disattivato.
• DebuggerStepThroughAttribute indica al debugger di eseguire un'istruzione dettagliata del codice a cui viene applicato, anziché eseguire l'istruzione nel codice.

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

Durante il debug di .NET:

• Eseguire il debug>dell'istruzione istruzione (o F11) nei passaggi del codice non utente sul codice alla riga successiva del codice utente.
• Debug>Istruzione/uscita (o MAIUSC+F11) nel codice non utente viene eseguito 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 si usa Debug>Interrompi tutto e si sospende nel codice non utente, viene visualizzata la finestra Nessuna origine. È quindi possibile usare un comando Debug>Step per passare alla riga successiva del codice utente.

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 l'istruzione di 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 la finestra Stack di chiamate e il 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 che contiene il codice utente deve essere caricato dal debugger (usare la finestra Moduli per verificarlo).

Per 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 di origine rimosse nei propri file di 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 delle istruzioni 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 %VsInstallDirectory%\Common7\Packages\Debugger\Visualizers .

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 delle istruzioni del codice e questo post di blog. Per il codice compilato con un compilatore precedente, i file natstepfilter sono l'unico modo per personalizzare l'istruzione di codice, indipendentemente da Just My Code. Vedere Personalizzare il comportamento delle istruzioni C++.

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

• Eseguire il debug>dell'istruzione Esegui istruzione (o F11) nei passaggi del codice non utente sul codice o viene eseguito alla riga successiva del codice utente, se viene chiamato Esegui istruzione da codice non utente.
• Esegui debug>istruzione/uscita (o MAIUSC+F11) nel codice non utente viene eseguito alla riga successiva del codice utente (all'esterno del frame 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 interrompe il codice non utente( ad esempio, si usa Debug>Interrompi tutto e si sospende nel codice non utente), l'istruzione 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. Le opzioni non gestite dall'utente nella finestra di dialogo Eccezione Impostazioni vengono ignorate.

Personalizzare lo stack di chiamate C++ e il comportamento di esecuzione delle istruzioni 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 nei file *.natjmc . Questa personalizzazione si applica anche alle istruzioni del codice se si usa il compilatore più recente (vedere C++ Just My Code).

• Per specificare il codice non utente per tutti gli utenti del computer che esegue Visual Studio, aggiungere il file con estensione natjmc alla cartella %VsInstallDirectory%\Common7\Packages\Debugger\Visualizers.
• Per specificare il codice non utente per un singolo utente, aggiungere il file natjmc alla cartella %U edizione Standard RPROFILE%\My Documents\<Visual Studio version>\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 modulo

Attributo	Descrizione
Name	Obbligatorio. Percorso completo del modulo o dei moduli. È possibile usare i caratteri ? jolly di Windows (zero o un carattere) e * (zero o più caratteri). ad esempio: <Module Name="?:\3rdParty\UtilLibs\*" /> indica al debugger di considerare tutti i moduli nella cartella \3rdParty\UtilLibs di qualsiasi unità come codice esterno.
Company	Facoltativo. Nome della società che pubblica il modulo che viene incorporato nel file eseguibile. È possibile utilizzare questo attributo per evitare ambiguità tra i moduli.

Attributi dell'elemento file

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

Attributi dell'elemento funzione

Attributo	Descrizione
Name	Obbligatorio. Nome completo della funzione da considerare come codice esterno. ou può usare i caratteri ? jolly di Windows e * quando si specifica il percorso.
Module	Facoltativo. Nome o percorso completo del modulo che contiene la funzione. È possibile utilizzare questo attributo per evitare ambiguità tra funzioni con lo stesso nome.
ExceptionImplementation	Se impostato su true, lo stack di chiamate mostra 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 funzioni da eseguire elencando come funzioni NoStepInto nei file *.natstepfilter . Le funzioni elencate nei file *.natstepfilter non dipendono dalle impostazioni Just My Code. Una funzione NoStepInto indica al debugger di eseguire il passaggio della funzione, anche se 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 %U edizione Standard RPROFILE%\My Documents\<Visual Studio version>\Visualizers.

Nota

Alcune estensioni di terze parti possono disabilitare la funzionalità natstepfilter .

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 in base a ECMA-262 che specifica il nome completo della funzione da mettere in corrispondenza. Ad esempio: <Name>MyNS::MyClass::.*</Name> indica al debugger che tutti i metodi in MyNS::MyClass devono essere considerati codice non utente. La corrispondenza prevede la distinzione tra maiuscole e minuscole.
Module	Facoltativo. Espressione regolare formattata in base a ECMA-262 che specifica il percorso completo del modulo che contiene la funzione. La corrispondenza non fa distinzione tra maiuscole e minuscole.
Action	Obbligatorio. Uno dei valori seguenti (viene effettuata la distinzione tra maiuscole e minuscole): NoStepInto : indica al debugger di eseguire il passaggio della funzione. StepInto : indica al debugger di eseguire l'istruzione nella funzione, sovrascrivendo qualsiasi altro NoStepInto elemento 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 direttamente alla soluzione o al progetto.

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

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

• Per le funzioni modello, l'uso di <.*> o <.* nel nome può essere utile.

JavaScript Just My Code

Just My Code in JavaScript controlla l'esecuzione e la visualizzazione dello stack di chiamate suddividendo il codice in una delle classificazioni seguenti:

Classificazione	Descrizione
MyCode	Codice utente che si possiede e si controlla.
LibraryCode	Codice non utente dalle librerie che usi regolarmente e l'app si basa su per funzionare correttamente (ad esempio, jQuery).
UnrelatedCode	Codice non utente nell'app di cui non si è proprietari e l'app non si basa per funzionare correttamente. Ad esempio, un SDK per la pubblicità che visualizza annunci potrebbe essere Non correlatoCode.

Il debugger JavaScript classifica il codice come utente o non utente in questo ordine:

1. Classificazioni predefinite.

   • Lo script eseguito passando una stringa alla funzione fornita dall'host eval è MyCode.
   • Lo script eseguito passando una stringa al Function costruttore è LibraryCode.
   • Lo script in un riferimento al framework, ad esempio WinJS o Azure SDK, è LibraryCode.
   • Lo script eseguito passando una stringa alle setTimeoutfunzioni , setImmediateo setInterval è UnrelatedCode.

2. Classificazioni nel file mycode.json del progetto corrente.

Ogni passaggio di classificazione esegue l'override dei passaggi precedenti.

Tutto il resto del codice viene classificato come MyCode.

È possibile modificare le classificazioni predefinite e classificare url e file specifici come codice utente o non utente aggiungendo un file .json denominato mycode.json alla cartella radice di un progetto JavaScript. Vedere Personalizzare JavaScript Just My Code.

Durante il debug di JavaScript:

• Se una funzione è codice non utente, Debug>Esegui istruzione (o F11) ha lo stesso comportamento di Debug>Step Over (o F10).
• Se un passaggio inizia nel codice non utente (LibraryCode o Non correlato), l'esecuzione di istruzioni si comporta temporaneamente come se Just My Code non sia abilitato. Quando si torna al codice utente, l'istruzione Just My Code viene riabilitata.
• Quando un passaggio di codice utente lascia il contesto di esecuzione corrente, il debugger si arresta alla riga di codice utente successiva eseguita. Se ad esempio un callback viene eseguito nel codice LibraryCode, il debugger continua finché la riga di codice utente successiva non viene eseguita.
• Esci (o MAIUSC+F11) si arresta nella 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.

I punti di interruzione impostati nel codice vengono sempre raggiunti, ma il codice viene classificato.

• Se la debugger parola chiave si verifica in LibraryCode, il debugger si interrompe sempre.
• Se la debugger parola chiave si verifica in UnrelatedCode, il debugger non si arresta.

Se si verifica un'eccezione non gestita nel codice MyCode o LibraryCode, il debugger si interrompe sempre.

Se si verifica un'eccezione non gestita in UnrelatedCode e MyCode o LibraryCode si trova nello stack di chiamate, il debugger si interrompe.

Se le eccezioni first-chance sono abilitate per l'eccezione e l'eccezione si verifica in LibraryCode o Non correlatoCode:

• Se l'eccezione è gestita, il debugger non si interrompe.
• Se l'eccezione non viene gestita, il debugger si interrompe.

Personalizzare JavaScript Just My Code

Per classificare il codice utente e non utente per un singolo progetto JavaScript, è possibile aggiungere un file .json denominato mycode.json alla cartella radice del progetto.

Il file mycode.json non deve elencare tutte le coppie chiave-valore. I valori MyCode, Libraries e Non correlati possono essere matrici vuote.

Mycode.json file usano questa sintassi:

{
    "Eval" : "Classification",
    "Function" : "Classification",
    "ScriptBlock" : "Classification",
    "MyCode" : [
        "UrlOrFileSpec",
        . . .
        "UrlOrFileSpec"
    ],
    "Libraries" : [
        "UrlOrFileSpec",
        . .
        "UrlOrFileSpec"
    ],
    "Unrelated" : [
        "UrlOrFileSpec",
        . . .
        "UrlOrFileSpec"
    ]
}

Eval, Function e ScriptBlock

Le coppie chiave-valore Eval, Function e ScriptBlock determinano come viene classificato il codice generato dinamicamente:

Nome	Descrizione
Eval	Script eseguito passando una stringa alla funzione eval fornita dall'host. Per impostazione predefinita, lo script Eval viene classificato come MyCode.
Funzione	Script eseguito passando una stringa al costruttore Function. Per impostazione predefinita, lo script Function viene classificato come LibraryCode.
ScriptBlock	Script eseguito passando una stringa alla funzione setTimeout, setImmediate o setInterval. Per impostazione predefinita, lo script ScriptBlock viene classificato come UnrelatedCode.

È possibile modificare il valore a una delle parole chiave seguenti:

• MyCode classifica lo script come MyCode.
• Library classifica lo script come LibraryCode.
• Unrelated classifica lo script come UnrelatedCode.

MyCode, Libraries e Unrelated

Le coppie chiave-valore MyCode, Libraries e Unrelated specificano gli URL o i file da includere in una classificazione:

Nome	Descrizione
MyCode	Matrice di URL o di file classificati come MyCode.
Raccolte	Matrice di URL o di file classificati come LibraryCode.
Unrelated	Matrice di URL o di file classificati come UnrelatedCode.

L'URL o la stringa di file può avere uno o più * caratteri, che corrispondono a zero o più caratteri. * è uguale all'espressione .*regolare .