Eu recentemente tenho mexido em torno com C # para C ++ interoperabilidade, em particular, a criação de uma função de retorno de chamada que é chamado a partir da DLL 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;
        }
    }
}

A questão que tenho é que, quando o controle do programa entra na função TomCallback, eu esperava que ele atingisse o loop while (true) no Main. No entanto, o programa apenas sai. Não consigo me acostumar com o comportamento, parte de mim imagina que isso é o esperado, mas parte de mim teria esperado que continuasse assim.

O que eu estava esperando ...

A função GetData () é chamadaA função GetData chama o retorno de chamadaA função de retorno de chamada retorna para GetDataGetData retorna para main ()

No entanto, isso não está certo.

Alguém seria gentil o suficiente para explicar o que acontece?

A fim de economizar espaço eu não postei o código não gerenciado, no entanto, se for necessário, eu estou feliz em postar

Editar: Liguei a depuração não gerenciada (esqueci completamente de fazer isso) e agora vejo o travamento ..

Falha de verificação de tempo de execução # 0 - O valor de ESP não foi salvo corretamente em uma chamada de função. Isso geralmente é resultado de chamar uma função declarada com uma convenção de chamada com um ponteiro de função declarado com uma convenção de chamada diferente.

Código nativo como este é o local onde o acidente é

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