Recientemente he estado jugando con la interoperabilidad de C # a C ++, especialmente al configurar una función de devolución de llamada que se llama desde la DLL de C ++.

namespace TomCSharpDLLImport
{
    class Program
    {
        public delegate void TomDelegate(int a, int b);

        [DllImport("TomDllNative.dll", CallingConvention = CallingConvention.Cdecl)]
        public static extern void GetData();

        [DllImport("TomDllNative.dll", CallingConvention = CallingConvention.Cdecl)]
        public static extern void SetCallback(TomDelegate aCallback);

        static void Main(string[] args)
        {
            TomDelegate lTD = new TomDelegate(Program.TomCallback);

            SetCallback(lTD); //Sets up the callback

            int thread = Thread.CurrentThread.ManagedThreadId;

            GetData(); //This calls the callback in unmanaged code

            while (true) ;
        }

        //Callback function which is called from the unmanaged code
        public static void TomCallback(int a, int b)
        {
            Console.WriteLine("A: {0} B: {1}", a, b);
            int thread = Thread.CurrentThread.ManagedThreadId;
        }
    }
}

La pregunta que tengo es que, cuando el control del programa entra en la función TomCallback, esperaba que llegara al bucle while (verdadero) en Main. Sin embargo, en cambio, el programa acaba de salir. No puedo entender el comportamiento, una parte de mí imagina que esto es como se esperaba, pero una parte de mí hubiera esperado que continuara.

Lo que esperaba ...

La función GetData () se llamaLa función GetData llama a la devolución de llamadaLa función de devolución de llamada vuelve a GetDataGetData vuelve a main ()

Sin embargo, esto no es del todo correcto.

¿Alguien sería lo suficientemente amable para explicar lo que sucede?

Para ahorrar espacio, no he publicado el código no administrado, sin embargo, si es necesario, me complace publicar

Editar: Activé la depuración no administrada (olvidé totalmente hacer esto) y ahora veo el bloqueo ...

Fallo en la verificación en tiempo de ejecución # 0: el valor de ESP no se guardó correctamente durante una llamada a la función. Este suele ser el resultado de llamar a una función declarada con una convención de llamada con un puntero de función declarado con una convención de llamada diferente.

Código nativo ya que aquí es donde se bloquea

#include "stdafx.h"
typedef void (*callback_function)(int, int);

extern "C" __declspec(dllexport) void SetCallback(callback_function aCallback);
extern "C" __declspec(dllexport) void GetData();

callback_function gCBF;

__declspec(dllexport) void SetCallback(callback_function aCallback)
{
    gCBF = aCallback;
}

__declspec(dllexport) void GetData()
{
    gCBF(1, 2);
}