Esercitazione: Eseguire il debug di C# e C++ nella stessa sessione di debug

Visual Studio consente di abilitare più tipi di debugger in una sessione di debug, denominata debug in modalità mista. In questa esercitazione si apprenderà come eseguire il debug di codice gestito e nativo in una singola sessione di debug.

Questa esercitazione illustra come eseguire il debug di codice nativo da un'app gestita, ma è anche possibile eseguire il debug di codice gestito da un'app nativa. Il debugger supporta anche altri tipi di debug in modalità mista, ad esempio il debug Python e il codice nativoe l'uso del debugger di script nei tipi di app, ad esempio ASP.NET.

In questa esercitazione si eseguiranno le seguenti attività:

Prerequisiti

Se non hai Visual Studio, vai alla pagina dei download di Visual Studio per installarlo gratuitamente.

Se Visual Studio è installato, ma non sono presenti i carichi di lavoro necessari, selezionare Apri il programma di installazione di Visual Studio nel riquadro sinistro della finestra di dialogo Nuovo progetto di Visual Studio. Nel programma di installazione di Visual Studio selezionare i carichi di lavoro necessari e quindi selezionare Modifica.

Creare una DLL nativa semplice

Per creare i file per il progetto DLL:

1. Aprire Visual Studio e creare un progetto.

   Premere esc per chiudere la finestra iniziale. Digitare CTRL + Q per aprire la casella di ricerca, digitare Progetto vuoto, scegliere Modelli, quindi scegliere Progetto vuoto per C++. Nella finestra di dialogo visualizzata scegliere Crea. Digitare quindi un nome come Mixed_Mode_Debugging e fare clic su Crea.

   Se non vedi il modello di progetto Progetto vuoto, vai a Tools>Get Tools and Features...per aprire il programma di installazione di Visual Studio. Viene avviato il programma di installazione di Visual Studio. Scegli il carico di lavoro Sviluppo desktop con C++, quindi scegli Modifica.

   Visual Studio crea il progetto.

2. In Esplora Soluzioni, selezionare File di originee quindi selezionare Progetto>Aggiungi Nuovo Elemento. In alternativa, fare clic con il pulsante destro del mouse File di origine e selezionare Aggiungi>Nuovo elemento.

   Se non vengono visualizzati tutti i modelli di elemento, scegliere Mostra tutti i modelli.

3. Nella finestra di dialogo Nuovo elemento selezionare file C++ (.cpp). Digitare Mixed_Mode.cpp nel campo Nome e quindi selezionare Aggiungi.

   Visual Studio aggiunge il nuovo file C++ a Esplora Soluzioni .

4. Copiare il codice seguente in Mixed_Mode.cpp:

   #include "Mixed_Mode.h"
   

5. In Esplora Soluzioni , selezionare Intestazione dei File e quindi selezionare Progetto >Aggiungi Nuovo Elemento. Oppure, fare clic con il pulsante destro del mouse su File di intestazione e selezionare Aggiungi>Nuovo elemento.

   Se non vengono visualizzati tutti i modelli di elemento, scegliere Mostra tutti i modelli.

6. Nella finestra di dialogo nuovo elemento, selezionare File di intestazione (.h). Digitare Mixed_Mode.h nel campo Nome e quindi selezionare Aggiungi.

   Visual Studio aggiunge il nuovo file di intestazione a Esplora Soluzioni.

7. Copiare il codice seguente in Mixed_Mode.h:

   #ifndef MIXED_MODE_MULTIPLY_HPP
   #define MIXED_MODE_MULTIPLY_HPP
   
   extern "C"
   {
     __declspec(dllexport) int __stdcall mixed_mode_multiply(int a, int b) {
       return a * b;
     }
   }
   #endif
   

8. Selezionare File>Salva tutto oppure premere Ctrl+Shift+S per salvare i file.

Per configurare e compilare il progetto DLL:

1. Nella barra degli strumenti di Visual Studio, selezionare la configurazione Debug e la piattaforma x86 o x64. Se l'app chiamante sarà .NET Core, che viene sempre eseguita in modalità a 64 bit, selezionare x64 come piattaforma.

2. In Esplora soluzioni, selezionare il nodo di progetto Mixed_Mode_Debugging e fare clic sull'icona Proprietà oppure fare clic con il pulsante destro del mouse sul nodo di progetto e selezionare Proprietà.

3. Nella parte superiore del riquadro Proprietà, verificare che la Configurazione sia impostata su Attiva (Debug) e che la Piattaforma sia uguale a quella impostata nella barra degli strumenti: x64o Win32 per la piattaforma x86.

   Importante

   Se si passa da x86 a x64 o viceversa, è necessario riconfigurare le proprietà per la nuova piattaforma.

4. In Proprietà di configurazione nel riquadro sinistro selezionare Linker>Advancede nell'elenco a discesa accanto a Nessun punto di ingressoselezionare No. Nel caso in cui dovessi cambiarlo in Nessuna, seleziona Applica.

5. In Proprietà di configurazioneselezionare Generalee nell'elenco a discesa accanto a Tipo di configurazioneselezionare libreria dinamica (.dll). Selezionare Applicae quindi selezionare OK.

   

6. Selezionare il progetto in Esplora soluzioni e quindi selezionare Compila>Compila soluzione, premere F7, oppure fare clic con il pulsante destro del mouse sul progetto e selezionare Compila.

   Il progetto deve essere compilato senza errori.

Creare una semplice app gestita per chiamare la DLL

1. Aprire Visual Studio e creare un nuovo progetto.

   Premere esc per chiudere la finestra iniziale. Digitare CTRL+ Q per aprire la casella di ricerca, digitare console, scegliere modelli e quindi scegliere app console per .NET Core o app console (.NET Framework) per C#. Nella finestra di dialogo visualizzata scegliere Avanti.

   Digitare quindi un nome come Mixed_Mode_Calling_App e fare clic su Avanti o Crea, a seconda dell'opzione disponibile.

   Per .NET Core scegliere il framework di destinazione consigliato o .NET 8 e quindi scegliere Crea.

   Se non viene visualizzato il modello di progetto corretto, vai a Strumenti>Ottieni strumenti e funzionalità..., che apre il programma di installazione di Visual Studio. Scegli il carico di lavoro .NET corretto come descritto nei prerequisiti, quindi seleziona Modifica.

   Nota

   È anche possibile aggiungere il nuovo progetto gestito alla soluzione C++ esistente. Il progetto viene creato in una nuova soluzione per rendere più difficile l'attività di debug in modalità mista.

   Visual Studio crea il progetto vuoto e lo visualizza in Esplora soluzioni .

2. Sostituire tutto il codice in Program.cs con il codice seguente:

   using System;
   using System.Runtime.InteropServices;
   
   namespace Mixed_Mode_Calling_App
   {
       public class Program
       {
           // Replace the file path shown here with the
           // file path on your computer. For .NET Core, the typical (default) path
           // for a 64-bit DLL might look like this:
           // C:\Users\username\source\repos\Mixed_Mode_Debugging\x64\Debug\Mixed_Mode_Debugging.dll
           // Here, we show a typical path for a DLL targeting the **x86** option.
           [DllImport(@"C:\Users\username\source\repos\Mixed_Mode_Debugging\Debug\Mixed_Mode_Debugging.dll", EntryPoint =
           "mixed_mode_multiply", CallingConvention = CallingConvention.StdCall)]
           public static extern int Multiply(int x, int y);
           public static void Main(string[] args)
           {
               int result = Multiply(7, 7);
               Console.WriteLine("The answer is {0}", result);
               Console.ReadKey();
           }
       }
   }
   

3. Nel nuovo codice, sostituisci il percorso del file in [DllImport] con il percorso del file del Mixed_Mode_Debugging.dll appena creato. Vedere il commento del codice per gli hint. Assicurati di sostituire il segnaposto nome utente.

4. Selezionare File>Salva Program.cs oppure premere CTRL+S per salvare il file.

Configurare il debug in modalità mista

1. In Esplora soluzioni, seleziona il nodo del progetto Mixed_Mode_Calling_App e seleziona l'icona Proprietà, oppure fai clic con il pulsante destro del mouse sul nodo del progetto e scegli Proprietà.

2. Abilitare il debug del codice nativo nelle proprietà.

   codice .NET

   Selezionare Debug nel riquadro sinistro, selezionare Apri interfaccia utente dei profili di avvio di debug, quindi selezionare la casella di controllo Abilita debug del codice nativo e quindi chiudere la pagina delle proprietà per salvare le modifiche.

   

   codice .NET Framework

   Nel menu a sinistra selezionare Debug. Nella sezione motori del debugger selezionare quindi la proprietà Abilita debug del codice nativo e quindi chiudere la pagina delle proprietà per salvare le modifiche.

   Selezionare Debug nel riquadro sinistro, selezionare la casella di controllo Abilita debug del codice nativo e quindi chiudere la pagina delle proprietà per salvare le modifiche.

   

3. Se si sta configurando una DLL x64 da un'app .NET Framework, modificare il target della piattaforma da Any CPU a x64. A tale scopo, potrebbe essere necessario selezionare Configuration Manager dal menu a tendina Piattaforma soluzione della barra degli strumenti di debug. Quindi, se non è possibile passare direttamente a x64, creare una Nuova configurazione destinata a x64.

Impostare un punto di interruzione e avviare il debug

1. Nel progetto C# aprire Program.cs. Impostare un punto di interruzione nella riga di codice seguente facendo clic sul margine sinistro, selezionando la riga e premendo F9oppure facendo clic con il pulsante destro del mouse sulla riga e selezionando punto di interruzione>Inserisci punto di interruzione.

   int result = Multiply(7, 7);
   

   Nel margine sinistro viene visualizzato un cerchio rosso in cui si imposta il punto di interruzione.

2. Premere F5, selezionare la freccia verde sulla barra degli strumenti di Visual Studio oppure selezionare Debug>Avvia debug per avviare il debug.

   Il debugger si interrompe al punto di interruzione che hai impostato. Una freccia gialla indica dove il debugger è attualmente in pausa.

Entrare e uscire dal codice nativo

1. Durante la sospensione del debug nell'applicazione gestita, premere F11oppure selezionare Debug>Passo dentro.

   Il file di intestazione nativo Mixed_Mode.h viene aperto, e vedi la freccia gialla nel punto in cui il debugger è sospeso.

   

   

2. A questo punto, è possibile impostare e raggiungere i punti di interruzione e controllare le variabili nel codice nativo o gestito.

   • Passare il puntatore del mouse sulle variabili nel codice sorgente per visualizzare i relativi valori.

   • Esaminare le variabili e i rispettivi valori nelle finestre Automatiche e Locali.

   • Mentre è in pausa nel debugger, è anche possibile usare le finestre di controllo e la finestra dello stack delle chiamate .

3. Premere di nuovo F11 per far avanzare il debugger di una riga.

4. Premere MAIUSC+F11 oppure selezionare Debug>Esegui fuori per continuare l'esecuzione e sospendere nuovamente nell'app gestita.

5. Premere F5 o selezionare la freccia verde per continuare il debug dell'app.

Felicitazioni! È stata completata l'esercitazione sul debug in modalità mista.

Passaggio successivo

In questa esercitazione si è appreso come eseguire il debug di codice nativo da un'app gestita abilitando il debug in modalità mista. Per una panoramica di altre funzionalità del debugger, vedere: