Compartir vía

Tutorial: Depuración de C# y C++ en la misma sesión de depuración

  • Artículo

Visual Studio permite habilitar más de un tipo de depurador en una sesión de depuración, lo que se denomina depuración en modo mixto. En este tutorial, se ofrece información para depurar código administrado y nativo en una única sesión de depuración.

En él se muestra cómo depurar código nativo desde una aplicación administrada, además de cómo depurar código administrado desde una aplicación nativa. El depurador también admite otros tipos de depuración en modo mixto, como la depuración de Python y código nativo, y el empleo del depurador de scripts en tipos de aplicaciones como ASP.NET.

En este tutorial va a:

  • Crear una DLL nativa simple
  • Crear una aplicación .NET Core o .NET Framework sencilla para llamar a la DLL
  • Configurar la depuración en modo mixto
  • Iniciar el depurador
  • Alcanzar un punto de interrupción en la aplicación administrada
  • Depurar paso a paso por instrucciones del código nativo

Requisitos previos

Debe tener instalado Visual Studio con las cargas de trabajo siguientes:

  • Desarrollo para el escritorio con C++
  • Desarrollo de escritorio de .NET

Debe tener instalado Visual Studio con las cargas de trabajo siguientes:

  • Desarrollo para el escritorio con C++
  • Desarrollo de escritorio de .NET o Desarrollo multiplataforma de .NET Core, en función del tipo de aplicación que quiera crear.

Si no tiene Visual Studio, vaya a la página de descargas de Visual Studio para instalarlo de forma gratuita.

Si tiene Visual Studio instalado, pero no las cargas de trabajo que necesita, seleccione Abrir el instalador de Visual Studio en el panel izquierdo del cuadro de diálogo Nuevo proyecto de Visual Studio. En el Instalador de Visual Studio, seleccione las cargas de trabajo necesarias y luego Modificar.

Crear una DLL nativa simple

Para crear los archivos del proyecto de DLL:

  1. Abra Visual Studio y cree un proyecto.

    Presione Esc para cerrar la ventana de inicio. Presione Ctrl + Q para abrir el cuadro de búsqueda, escriba Proyecto vacío, elija Plantillas y, luego, Proyecto vacío para C++. En el cuadro de diálogo que se abre, elija Crear. Luego, escriba un nombre como Mixed_Mode_Debugging y haga clic en Crear.

    Si no ve la plantilla de proyecto Proyecto vacío, vaya a Herramientas>Obtener herramientas y características… y se abrirá el instalador de Visual Studio. Se iniciará el Instalador de Visual Studio. Seleccione la carga de trabajo Desarrollo para el escritorio con C++ y, luego, elija Modificar.

    Visual Studio crea el proyecto.

  2. En el Explorador de soluciones, seleccione Archivos de código fuente y luego Proyecto>Agregar nuevo elemento. O bien, haga clic con el botón derecho en Archivos de código fuente y seleccione Agregar>Nuevo elemento.

    Si no ve todas las plantillas de elemento, seleccione Mostrar todas las plantillas.

  3. En el cuadro de diálogo Nuevo elemento, seleccione Archivo C++ (.cpp) . En el campo Nombre, escriba Mixed_Mode.cpp y seleccione Agregar.

    Visual Studio agrega el nuevo archivo de C++ al Explorador de soluciones.

  4. Copie el siguiente código en Mixed_Mode.cpp:

    #include "Mixed_Mode.h"

  5. En el Explorador de soluciones, seleccione Archivos de encabezado y luego Proyecto>Agregar nuevo elemento. O bien, haga clic con el botón derecho en Archivos de encabezado y seleccione Agregar>Nuevo elemento.

    Si no ve todas las plantillas de elemento, seleccione Mostrar todas las plantillas.

  6. En el cuadro de diálogo Nuevo elemento, seleccione Archivo de encabezado (.h) . En el campo Nombre, escriba Mixed_Mode.h y seleccione Agregar.

    Visual Studio agrega el nuevo archivo de encabezado al Explorador de soluciones.

  7. Copie el siguiente código en 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. Seleccione Archivo>Guardar todo o presione Ctrl+Mayús+S para guardar los archivos.

Para configurar y compilar el proyecto de DLL:

  1. En la barra de herramientas de Visual Studio, seleccione la opción Depurar y la plataforma x86 o x64. Si la aplicación que realiza la llamada va a ser .NET Core, que siempre se ejecuta en modo de 64 bits, seleccione x64 como plataforma.

  2. En el Explorador de soluciones, seleccione el nodo del proyecto Mixed_Mode_Debugging y el icono Propiedades o haga clic con el botón derecho en el nodo del proyecto y seleccione Propiedades.

  3. En la parte superior del panel Propiedades, asegúrese de que Configuración esté establecido en Activo (Depurar) y Plataforma sea la misma que la establecida en la barra de herramientas: x64 o Win32 para la plataforma x86.

    Importante

    Si cambia la plataforma de x86 a x64 o viceversa, debe volver a configurar las propiedades de la nueva plataforma.

  4. En Propiedades de configuración, en el panel izquierdo, seleccione Enlazador>Avanzadas y, en la lista desplegable situada junto a Ningún punto de entrada, seleccione No. Si ha tenido que cambiar a No, seleccione Aplicar.

  5. En Propiedades de configuración, seleccione General y, en la lista desplegable situada junto a Tipo de configuración, seleccione Biblioteca dinámica (.dll) . Seleccione Aplicar y luego Aceptar.

    Switch to a native DLL

  6. Seleccione el proyecto en el Explorador de soluciones y luego Compilar>Compilar solución, presione F7, o haga clic con el botón derecho en el proyecto y seleccione Compilar.

    El proyecto se debe compilar sin errores.

Crear una aplicación administrada simple para llamar a la DLL

  1. Abra Visual Studio y cree un nuevo proyecto.

    Presione Esc para cerrar la ventana de inicio. Presione Ctrl + Q para abrir el cuadro de búsqueda, escriba consola, elija Plantillas y, luego, Aplicación de consola para .NET Core o Aplicación de consola (.NET Framework) para C#. En el cuadro de diálogo que aparece, elija Siguiente.

    A continuación, escriba un nombre como Mixed_Mode_Calling_App y haga clic en Siguiente o Crear, independientemente de la opción que esté disponible.

    En .NET Core, elija la plataforma de destino recomendada o .NET 8; después, elija Crear.

    Si no ve la plantilla de proyecto correcta, vaya a Herramientas>Obtener herramientas y características... para abrir el Instalador de Visual Studio. Elija la carga de trabajo adecuada de .NET tal y como se describe en los requisitos previos y después elija Modificar.

    Nota

    También puede agregar el nuevo proyecto administrado a la solución existente de C++. Estamos creando el proyecto en una nueva solución para que la tarea de depuración en modo mixto sea más difícil.

    Visual Studio crea el proyecto vacío y lo muestra en el Explorador de soluciones.

  2. Reemplace todo el código de Program.cs por el siguiente:

    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. En el nuevo código, reemplace la ruta de acceso de archivo de [DllImport] por la ruta de acceso de archivo de Mixed_Mode_Debugging.dll que acaba de crear. Vea el comentario del código para obtener sugerencias. Asegúrese de reemplazar el marcador de posición username.

  4. Seleccione Archivo>Guardar Program.cs o presione Ctrl+S para guardar el archivo.

Configurar la depuración en modo mixto

  1. En el Explorador de soluciones, seleccione el nodo del proyecto Mixed_Mode_Calling_App y el icono Propiedades o haga clic con el botón derecho en el nodo del proyecto y seleccione Propiedades.

  2. Habilite la depuración de código nativo en las propiedades.

    Seleccione Depurar en el panel izquierdo, seleccione Abrir la interfaz de perfiles de inicio de depuración, después seleccione la casilla Habilitar depuración de código nativo y cierre la página de propiedades para guardar los cambios. Enable mixed mode debugging

    Seleccione Depurar en el panel izquierdo, active la casilla Habilitar depuración de código nativo y cierre la página de propiedades para guardar los cambios.

    Enable mixed mode debugging

  3. Si tiene como destino una DLL x64 de una aplicación de .NET Framework, cambie el destino de plataforma de Cualquier CPU a x64. Para ello, es posible que tenga que seleccionar Configuration Manager en la lista desplegable Plataforma de soluciones de la barra de herramientas de depuración. Después, si no puede cambiar directamente a x64, cree una nueva configuración con x64 como destino.

Establecer un punto de interrupción e iniciar la depuración

  1. En el proyecto de C#, abra Program.cs. Para establecer un punto de interrupción en la siguiente línea de código, haga clic en el margen izquierdo, seleccione la línea y presione F9, o bien haga clic con el botón derecho en la línea y seleccione Punto de interrupción>Insertar punto de interrupción.

    int result = Multiply(7, 7);

    En el margen izquierdo donde ha establecido el punto de interrupción aparece un círculo rojo.

  2. Presione F5, seleccione la flecha verde de la barra de herramientas de Visual Studio, o seleccione Depurar>Iniciar depuración para iniciar la depuración.

    El depurador se detiene en el punto de interrupción establecido. Una flecha amarilla indica dónde se ha detenido el depurador.

Depurar paso a paso por instrucciones del código nativo

  1. Mientras la depuración está detenida en la aplicación administrada, presione F11, o bien seleccione Depurar>Depurar paso a paso por instrucciones.

    Se abre el archivo de encabezado nativo Mixed_Mode.h y se ve la flecha amarilla donde se ha detenido el depurador.

    Step into native code

    Step into native code

  2. Ahora es posible establecer y alcanzar puntos de interrupción e inspeccionar variables en el código nativo o administrado.

    • Mantenga el puntero sobre las variables del código fuente para ver sus valores.

    • Examine las variables y sus valores en las ventanas Automático y Locales.

    • Mientras el depurador está detenido, también puede usar las ventanas Inspección y Pila de llamadas.

  3. Presione F11 de nuevo para que el depurador avance una línea.

  4. Presione Mayús+F11 o seleccione Depurar>Paso a paso para salir para seguir ejecutando y volver a detener en la aplicación administrada.

  5. Presione F5 o seleccione la flecha verde para seguir depurando la aplicación.

¡Enhorabuena! Ha completado el tutorial sobre la depuración en modo mixto.

Paso siguiente

En este tutorial, ha aprendido a depurar código nativo desde una aplicación administrada al habilitar la depuración en modo mixto. Para obtener información general sobre otras características del depurador, vea:

Primer vistazo al depurador