Eseguire il debug di più processi (C#, Visual Basic, C++)

Visual Studio può eseguire il debug di una soluzione con diversi processi. È possibile avviare e passare da processi, interrompere, continuare ed eseguire istruzioni dettagliate nell'origine, arrestare il debug e terminare o scollegare i singoli processi.

Avviare il debug con più processi

Quando più progetti in una soluzione di Visual Studio possono essere eseguiti in modo indipendente, è possibile selezionare il progetto avviato dal debugger. Il progetto di avvio corrente viene visualizzato in grassetto in Esplora soluzioni.

Per modificare il progetto di avvio, in Esplora soluzioni fare clic con il pulsante destro del mouse su un progetto diverso e scegliere Imposta come progetto di avvio.

Per avviare il debug di un progetto da Esplora soluzioni senza renderlo il progetto di avvio, fare clic con il pulsante destro del mouse sul progetto e scegliere Avvia debug>nuova istanza o Esegui istruzione in una nuova istanza.

Per impostare il progetto di avvio o più progetti dalle proprietà della soluzione:

1. Selezionare la soluzione in Esplora soluzioni e quindi selezionare l'icona Proprietà sulla barra degli strumenti oppure fare clic con il pulsante destro del mouse sulla soluzione e scegliere Proprietà.

2. Nella pagina Proprietà selezionare Progetto di avvio proprietà>comuni.

   

3. Selezionare Selezione corrente, Progetto di avvio singolo e file di progetto oppure Progetti di avvio multipli.

   Se si seleziona Più progetti di avvio, è possibile modificare l'ordine di avvio e l'azione da eseguire per ogni progetto: Avvia, Avvia senza eseguire il debug o Nessuno.

4. Selezionare Applica o OK per applicare e chiudere la finestra di dialogo.

Collegarsi a un processo

Il debugger può anche connettersi alle app in esecuzione nei processi all'esterno di Visual Studio, inclusi nei dispositivi remoti. Dopo aver eseguito il collegamento a un'app, è possibile usare il debugger di Visual Studio. Le funzionalità di debug potrebbero essere limitate. Dipende dal fatto che l'app sia stata compilata con informazioni di debug, se si ha accesso al codice sorgente dell'app e se il compilatore JIT sta monitorando le informazioni di debug.

Per altre informazioni, vedere Connettersi ai processi in esecuzione.

Per connettersi a un processo in esecuzione:

1. Con l'app in esecuzione selezionare Debug>Connetti a processo.

   

2. Nella finestra di dialogo Connetti a processo selezionare il processo dall'elenco Processi disponibili e quindi selezionare Collega.

Nota

Il debugger non si connette automaticamente a un processo figlio che viene avviato da un processo sottoposto a debug, anche se il progetto figlio si trova nella stessa soluzione. Per eseguire il debug di un processo figlio, collegarsi al processo figlio dopo l'avvio o configurare l'editor del Registro di sistema di Windows per avviare il processo figlio in una nuova istanza del debugger.

Usare l'editor del Registro di sistema per avviare automaticamente un processo nel debugger

In alcuni casi, potrebbe essere necessario eseguire il debug del codice di avvio per un'app avviata da un altro processo. Può ad esempio trattarsi di servizi o operazioni di installazione personalizzate. È possibile avviare il debugger e collegarsi automaticamente all'app.

1. Avviare l'editor del Registro di sistema di Windows eseguendo regedit.exe.

2. In Editor del Registro di sistema passare a HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion\Image File Execution Options.

3. Selezionare la cartella dell'app da avviare nel debugger.

   Se l'app non è elencata come cartella figlio, fare clic con il pulsante destro del mouse su Opzioni di esecuzione file di immagine, selezionare Nuova>chiave e digitare il nome dell'app. In alternativa, fare clic con il pulsante destro del mouse sulla nuova chiave nell'albero, scegliere Rinomina e quindi immettere il nome dell'app.

4. Fare clic con il pulsante destro del mouse sulla nuova chiave nell'albero e scegliere Nuovo>valore stringa.

5. Modificare il nome del nuovo valore da Nuovo valore #1 a debugger.

6. Fare clic con il pulsante destro del mouse sul debugger e scegliere Modifica.

   

7. Nella finestra di dialogo Modifica stringa digitare vsjitdebugger.exe nella casella Dati valore e quindi selezionare OK.

   

Eseguire il debug con più processi

Quando si esegue il debug di un'app con diversi processi, i comandi di interruzione, istruzione e continuazione del debugger influiscono su tutti i processi per impostazione predefinita. Ad esempio, quando un processo viene sospeso in corrispondenza di un punto di interruzione, viene sospesa anche l'esecuzione di tutti gli altri processi. È possibile modificare questo comportamento predefinito per ottenere un maggiore controllo sulle destinazioni dei comandi di esecuzione.

Per modificare se tutti i processi vengono sospesi quando si interrompe un processo:

• In Strumenti (o Debug) >Opzioni>debug>Generale selezionare o deselezionare la casella di controllo Interrompi tutti i processi quando si interrompe un processo.

Interrompere, eseguire il passaggio e continuare i comandi

Nella tabella seguente vengono descritti i comportamenti dei comandi di debug quando viene selezionata o deselezionata la casella di controllo Interrompi tutti i processi quando viene selezionata o deselezionata un'interruzione di processo :

Comando	Selected	Deselezionato
Debug>Interrompi tutto	Interruzione di tutti i processi.	Interruzione di tutti i processi.
Continuazione debug>	Ripresa di tutti i processi.	Ripresa di tutti i processi sospesi.
Eseguire il debug>dell'istruzione, eseguire un'istruzione/routine o eseguire l'istruzione/routine	Esecuzione di tutti i processi durante l'esecuzione delle istruzioni del processo corrente. Successiva interruzione di tutti i processi.	Esecuzione delle istruzioni del processo corrente. Ripresa dei processi sospesi. Continuazione dei processi in esecuzione.
Eseguire il debug>nel processo corrente, eseguire il passaggio al processo corrente o eseguire l'istruzione al di fuori del processo corrente	N/D	Esecuzione delle istruzioni del processo corrente. Mantenimento dello stato esistente (sospeso o in esecuzione) degli altri processi.
Punto di interruzione della finestra di origine	Interruzione di tutti i processi.	Interruzione solo del processo della finestra di origine.
Finestra di origine Esegui al cursore La finestra di origine deve essere nel processo corrente.	Esecuzione di tutti i processi mentre il processo della finestra di origine viene eseguito fino al cursore e quindi interrotto. Successiva interruzione di tutti gli altri processi.	Esecuzione del processo della finestra di origine fino al cursore. Mantenimento dello stato esistente (sospeso o in esecuzione) degli altri processi.
Processo di interruzione della finestra >Processi	N/D	Interruzione del processo selezionato. Mantenimento dello stato esistente (sospeso o in esecuzione) degli altri processi.
Finestra >Processi Continua processo	N/D	Ripresa del processo selezionato. Mantenimento dello stato esistente (sospeso o in esecuzione) degli altri processi.

Trovare i file di origine e simbolo (con estensione pdb)

Per spostarsi nel codice sorgente di un processo, il debugger deve accedere ai file di origine e ai file di simboli. Per altre informazioni, vedere Specificare file di simboli (PDB) e di origine.

Se non è possibile accedere ai file per un processo, è possibile spostarsi usando la finestra Disassembly . Per altre informazioni, vedere Procedura: Usare la finestra Disassembly.

Passare da un processo all'altro

È possibile connettersi a più processi durante il debug, ma solo un processo è attivo nel debugger in qualsiasi momento. È possibile impostare il processo attivo o corrente nella barra degli strumenti Posizione di debug o nella finestra Processi. Per passare da un processo all'altro, entrambi i processi devono essere in modalità di interruzione.

Per impostare il processo corrente dalla barra degli strumenti Percorso di debug:

1. Per aprire la barra degli strumenti Percorso debug, selezionare Visualizza>barre degli strumenti>Percorso debug.

2. Durante il debug, sulla barra degli strumenti Percorso di debug selezionare il processo che si vuole impostare come processo corrente dall'elenco a discesa Processo .

   

Per impostare il processo corrente dalla finestra Processi:

1. Per aprire la finestra Processi, durante il debug, selezionare Debug>processi Windows.>

2. Nella finestra Processi il processo corrente è contrassegnato da una freccia gialla. Fare doppio clic sul processo che si desidera impostare come processo corrente.

   

Il passaggio a un processo lo imposta come processo corrente a scopo di debug. Le finestre del debugger mostrano lo stato per il processo corrente e i comandi di esecuzione delle istruzioni influiscono solo sul processo corrente.

Arrestare il debug con più processi

Per impostazione predefinita, quando si seleziona Debug>arresta debug, il debugger termina o si scollega da tutti i processi.

• Se il processo corrente è stato avviato nel debugger, il processo viene terminato.

• Se il debugger è stato connesso al processo corrente, viene disconnesso e il processo rimane in esecuzione.

Se si avvia il debug di un processo da una soluzione di Visual Studio, connettersi a un altro processo già in esecuzione e quindi scegliere Arresta debug, la sessione di debug termina. Il processo avviato in Visual Studio termina, mentre il processo associato a continua esecuzione.

Per controllare il modo in cui Arresta debug influisce su un singolo processo, nella finestra Processi fare clic con il pulsante destro del mouse su un processo e quindi selezionare o deselezionare la casella di controllo Scollega al termine del debug.

Nota

L'opzione Interrompi tutti i processi quando un processo interrompe il debugger non influisce sull'arresto, la terminazione o la disconnessione dai processi.

Interrompere, terminare e disconnettere i comandi

La tabella seguente descrive i comportamenti dei comandi di arresto, terminazione e scollegamento del debugger con più processi:

Comando	Descrizione
Debug>arresta debug	A meno che il comportamento non venga modificato nella finestra Processi , i processi avviati dal debugger vengono terminati e i processi collegati vengono scollegati.
Debug>Termina tutto	Tutti i processi vengono terminati.
Debug>Scollega tutto	Il debugger si disconnette da tutti i processi.
Processo di scollegamento della finestra >Processi	Il debugger si disconnette da tutti i processi selezionati. Mantenimento dello stato esistente (sospeso o in esecuzione) degli altri processi.
>Finestra Processi Termina processo	Il processo selezionato è terminato. Mantenimento dello stato esistente (sospeso o in esecuzione) degli altri processi.
>Finestra Processi Scollegamento durante l'arresto del debug	Se questa opzione è selezionata, debug>arresta debug scollega dal processo selezionato. Se non è selezionata, debug>arresta debug termina il processo selezionato.

Contenuto correlato

• Specificare file di simboli (PDB) e di origine
• Connettersi a processi in esecuzione
• Spostarsi nel codice con il debugger
• Debug JIT
• Debug di applicazioni multithreading