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 tra i processi, interrompere, continuare ed eseguire passo passo nel codice sorgente, arrestare il debug e concludere o separare dai 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 eseguirne 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 Proprietà comuni>Progetto di avvio.

   

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.

Annotazioni

Il debugger non si collega automaticamente a un processo figlio 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. Gli esempi includono servizi e azioni 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. Nell'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 figlia, fare clic con il tasto destro 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 'break', 'step' e 'continue' 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:

1. Nel riquadro Strumenti (o Debug) >Opzioni, espandere la sezione Tutte le impostazioni>, Debugging>, Generale.

2. Selezionare o deselezionare la casella di controllo Interrompi tutti i processi quando si interrompe un processo .

Comandi Break, Step, Continue

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	Selezionato	Deselezionata
Debug>Interrompi tutto il processo	Tutti i processi si interrompono.	Tutti i processi si interrompono.
Debug>Continuare	Tutti i processi riprendono.	Tutti i processi sospesi riprendono.
Debug>Esegui istruzione, Salta istruzione, o Esci dall'istruzione	Tutti i processi vengono eseguiti durante i passaggi correnti del processo. Quindi tutti i processi si interrompono.	Passaggi correnti del processo. Riprendi i processi sospesi. I processi in esecuzione continuano.
Debug>Esegui istruzione nel processo corrente, eseguire il passaggio oltre il processo corrente o uscire dal processo corrente	N/A	Passaggi correnti del processo. Altri processi mantengono lo stato esistente (sospeso o in esecuzione).
Punto di interruzione della finestra di origine	Tutti i processi si interrompono.	Solo il processo della finestra di origine va in errore.
Finestra Esegui fino al cursore La finestra di origine deve essere nel processo corrente.	Tutti i processi vengono eseguiti contemporaneamente al processo della finestra principale fino a quando questo raggiunge il cursore e si interrompe. Quindi tutti gli altri processi si interrompono.	Il processo della finestra di origine viene eseguito fino al cursore. Altri processi mantengono lo stato esistente (sospeso o in esecuzione).
Processi finestra >Interrompi Processo	N/A	Interruzioni di processo selezionate. Altri processi mantengono lo stato esistente (sospeso o in esecuzione).
Finestra> Processi Continua processo	N/A	Il processo selezionato riprende. Altri processi mantengono lo stato esistente (sospeso o in esecuzione).

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 ulteriori informazioni, vedere Specificare simboli (.pdb) e file sorgente.

Se non è possibile accedere ai file di un processo, puoi navigare 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 Percorso 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 Posizione 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>.

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 del processo corrente e i comandi di avanzamento influiscono solo sul processo corrente.

Interrompere il debug con multipli 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 collegato al processo corrente, il debugger si disconnette dal processo e lascia in esecuzione il processo.

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 continua l'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 .

Annotazioni

L'opzione Interrompi tutti i processi quando uno si arresta nel debugger non influisce sull'arresto, sulla terminazione o sulla disconnessione dai processi.

Arrestare, terminare e scollegare 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>Disconnetti tutto	Il debugger si disconnette da tutti i processi.
Processi>Distacca Processo	Il debugger si scollega dal processo selezionato. Altri processi mantengono lo stato esistente (sospeso o in esecuzione).
Processi finestra >Termina Processo	Il processo selezionato è terminato. Altri processi mantengono lo stato esistente (sospeso o in esecuzione).
Finestra Processi>Scollega quando il debug si ferma	Se questa opzione è selezionata, Debug>Arresta il debug si scollega dal processo selezionato. Se non è selezionata, debug>arresta debug termina il processo selezionato.

Contenuti correlati

• Specificare i file di simbolo (.pdb) e di sorgente
• Connettersi ai processi in esecuzione
• Esplorazione del codice con il debugger
• Semplice debugIn-Time
• Eseguire il debug di applicazioni multithreading