Question

I have recently been tinkering around with C# to C++ interop, in particularly setting up a callback function which is called from the C++ DLL.

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

The question I have is that, when the program control comes into the TomCallback function, I was expecting it to then hit the while(true) loop in Main. However instead the program just exits. I can’t quite get my head round the behaviour, part of me imagines this is as expected but part of me would have expected it to continue on in main.

What I was expecting…

1. The GetData() function is called
2. The GetData function calls the callback
3. The callback function returns back to GetData
4. GetData returns back to main()

However this is not quite right.

Would someone be kind enough to explain what happens.

In order to save space I haven’t posted the unmanaged code, however if it is needed i’m happy to post

Edit:
I turned on Unmanaged debugging (totally forgot to do this) and now I see the crash..

Run-Time Check Failure #0 – The value of ESP was not properly saved across a function call. This is usually a result of calling a function declared with one calling convention with a function pointer declared with a different calling convention.

Native code as this is where crash is

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

Answer 1

You must convert your managed callback to the Native Function Pointer (IntPtr in C#) by using the

IntPtr Marshal.GetFunctionPointerForDelegate(Delegate d)

method.

Your usage of SetCallback() with System.Delegate as an argument is wrong.

Make it

SetCallback(Marshal.GetFunctionPointerForDelegate(lTD));

and redeclare SetCallback as

/// StdCall is crucial here
[DllImport("TomDllNative.dll", CallingConvention = CallingConvention.StdCall)]
public static extern void SetCallback(IntPtr aCallback);