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

Articolo
10/24/2023

Visual Studio consente di abilitare più di un tipo di debugger in una sessione di debug, chiamata debug in modalità mista. In questa esercitazione viene illustrato come eseguire il debug di codice nativo e gestito 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 di codice Python e nativo e l'uso del debugger di script in tipi di app come ad esempio ASP.NET.

Questa esercitazione illustra come:

Creare una semplice DLL nativa
Creare una semplice app .NET Core o .NET Framework per chiamare la DLL
Configurare il debug in modalità mista
Avviare il debugger
Raggiungere un punto di interruzione nell'app gestita
Eseguire l'istruzione del codice nativo

Prerequisiti

È necessario avere installato Visual Studio, con i carichi di lavoro seguenti:

Sviluppo per desktop con C++
Sviluppo di applicazioni desktop .NET

È necessario avere installato Visual Studio, con i carichi di lavoro seguenti:

Sviluppo per desktop con C++
Sviluppo di applicazioni desktop .NET o sviluppo multipiattaforma .NET Core, a seconda del tipo di app che si vuole creare.

Se Visual Studio non è disponibile, passare alla pagina dei download di Visual Studio per installarlo gratuitamente.

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

Creare una semplice DLL nativa

Per creare i file per il progetto DLL:

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. Quindi, digitare un nome simile a Mixed_Mode_Debugging e fare clic su Crea.

Se il modello di progetto Progetto vuoto non viene visualizzato, passare a Strumenti>Ottieni strumenti e funzionalità... per aprire il programma di installazione di Visual Studio. Verrà avviato il Programma di installazione di Visual Studio. Selezionare il carico di lavoro Sviluppo di applicazioni desktop con C++, quindi scegliere Modifica.

Visual Studio crea il progetto.
In Esplora soluzioni selezionare File di origine e in seguito Progetto>Aggiungi nuovo elemento. In alternativa, fare clic con il pulsante destro del mouse su File di origine e selezionare Aggiungi>Nuovo elemento.

Se non vengono visualizzati tutti i modelli di elemento, scegliere Mostra tutti i modelli.
Nella finestra di dialogo Nuovo elemento selezionare File di C++ (.cpp). Digitare Mixed_Mode.cpp nel campo Nome e quindi selezionare Aggiungi.

Visual Studio aggiunge il nuovo file di C++ in Esplora soluzioni.
Copiare il codice seguente nel file Mixed_Mode.cpp:
```
#include "Mixed_Mode.h"
```
In Esplora soluzioni selezionare File di intestazione e quindi Progetto>Aggiungi nuovo elemento. In alternativa, 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.
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 in Esplora soluzioni.

Copiare il codice seguente nel file 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

Selezionare File>Salva tutto oppure premere CTRL+MAIUSC+S per salvare i file.

Per configurare e compilare il progetto DLL:

Sulla barra degli strumenti di Visual Studio selezionare la configurazione Debug e la piattaforma x86 oppure x64. Se l'app chiamante è .NET Core, che viene sempre eseguita in modalità a 64 bit, selezionare la piattaforma x64.
In Esplora soluzioni selezionare il nodo del progetto Mixed_Mode_Debugging e quindi l'icona Proprietà oppure fare clic con il pulsante destro del mouse sul nodo del progetto e scegliere Proprietà.
Nella parte superiore del riquadro Proprietà assicurarsi che il valore di Configurazione sia impostato su Attiva (debug) e che la Piattaforma sia la stessa impostata sulla barra degli strumenti: x64 o Win32 per la piattaforma x86.

Importante

Se si passa dalla piattaforma x86 alla x64 o viceversa, è necessario riconfigurare le proprietà per la nuova piattaforma.
In Proprietà di configurazione nel riquadro a sinistra selezionare Linker>Avanzate e nell'elenco a discesa accanto a Nessun punto di ingresso selezionare No. Se è necessario apportare una modifica per impostare il campo su No, selezionare Applica.
In Proprietà di configurazione selezionare Generale e nell'elenco a discesa accanto a Tipo di configurazione selezionare Libreria dinamica (.dll). Selezionare Apply (Applica) e quindi OK.
Selezionare il progetto in Esplora soluzioni e quindi selezionare Compila>Compila soluzione, premere F7 o fare clic con il pulsante destro del mouse sul progetto e selezionare Compila.

Il progetto dovrebbe essere compilato senza errori.

Creare una semplice app gestita per chiamare la DLL

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 qualsiasi opzione sia disponibile.

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

Se il modello di progetto corretto non è visualizzato, passare a Strumenti Ottieni strumenti>e funzionalità, che apre il Programma di installazione di Visual Studio. Scegliere il carico di lavoro .NET corretto come descritto nei prerequisiti e quindi scegliere 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.

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();
        }
    }
}

Nel nuovo codice sostituire il percorso del file in [DllImport] con il percorso per la DLL Mixed_Mode_Debugging.dll appena creata. Vedere il commento del codice per i suggerimenti. Assicurarsi di sostituire il segnaposto username.
Selezionare File>Save Program.cs oppure premere CTRL+S per salvare il file.

Configurare il debug in modalità mista

In Esplora soluzioni selezionare il nodo del progetto Mixed_Mode_Calling_App e quindi l'icona Proprietà oppure fare clic con il pulsante destro del mouse sul nodo del progetto e scegliere Proprietà.
Abilitare il debug del codice nativo nelle proprietà.

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

Selezionare Debug nel riquadro a sinistra, selezionare la casella di controllo Abilita debug codice nativo e chiudere la pagina delle proprietà per salvare le modifiche.
Se si usa una DLL x64 da un'app .NET Framework, modificare la destinazione della piattaforma da Qualsiasi CPU a x64. A tale scopo, potrebbe essere necessario selezionare Configuration Manager dall'elenco a discesa Piattaforma soluzione della barra degli strumenti 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

Nel progetto C# aprire Program.cs. Impostare un punto di interruzione nella riga di codice seguente facendo clic sul margine di estrema sinistra, selezionando la riga e premendo F9, oppure facendo clic sulla riga e selezionando Punto di interruzione>Inserisci punto di interruzione.
```
int result = Multiply(7, 7);
```
In corrispondenza del punto di interruzione viene visualizzato un cerchio rosso.
Premere F5, selezionare la freccia verde sulla barra degli strumenti di Visual Studio, o selezionare Debug>Avvia debug per avviare il debug.

Il debugger si fermerà in corrispondenza del punto di interruzione impostato. Una freccia gialla indica il punto in cui il debugger è attualmente in pausa.

Eseguire istruzioni e uscire dal codice nativo

Mentre il debug è in pausa nell'app gestita, premere F11 o selezionare Debug>Esegui istruzione.

Si apre il file di intestazione nativo Mixed_Mode.h e viene visualizzata la freccia gialla nel punto in cui il debugger è in pausa.
A questo punto, è possibile impostare e raggiungere i punti di interruzione e ispezionare le variabili nel codice nativo o gestito.
- Passare il mouse sulle variabili nel codice sorgente per visualizzare i relativi valori.
- Esaminare le variabili e i relativi valori nelle finestre Auto e Variabili locali.
- Durante la pausa del debugger, è anche possibile usare le finestre Espressione di controllo e Stack di chiamate.
Premere nuovamente F11 per fare avanzare il debugger di una riga.
Premere MAIUSC+F11 oppure selezionare Debug>Esci da istruzione/routine per continuare l'esecuzione e sospenderla di nuovo nell'app gestita.
Premere F5 o selezionare la freccia verde per continuare il debug dell'app.

Complimenti. L'esercitazione sull'esecuzione del debug in modalità mista è stata completata.

Passaggio successivo

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

Presentazione del debugger

Condividi tramite