通过托管C ++包装程序从非托管C ++ dll运行C＃函数

Question

I am working on a C# project that uses some unmanaged C++ code encapsulated in a dll. I have to load that dll as a Reference (not DllImport), so I'm writing a managed C++ Wrapper as a bridge between C# and the dll.

I can easily call the dll functions from C#, just calling the equivalent functions in the wrapper from C#, and then calling the dll functions from the wrapper. However, there are some callback functions in the dll that should call C# functions, and that part doesn't work. I have studied several tutorials about this kind of interop (stackoverflow, microsoft, codeproject), but they are quite old and I can't make them work.

The idea is that the dll is processing real time data, and everytime the dll generates some results, it should call a function in Program.cs, which uses those results.

The code I'm working on is huge, so I've made a very simple scenario that includes everything that doesn't work.

In Program.cs I'm trying to tell the dll: "take this function Test and call it when you are done". Then, to test it, I force it to run the callback function. But I find several errors.

Although wrapper compiles and generates wrapper.dll, when I load it in the C# project, the function M_setCallback isn't there ¿?.

I wonder if somebody could give me a hand or show me a tutorial that explains how to do that (the tutorials I found don't have the 3 projects I must use, and I can't make them work). I have tried using delegates, but the program crashes.

Or maybe there is a simpler way to do this.

Thanks!

Here is the code, it's very simple:

First, I have the unmanaged dll : C++ Project, Win32 Console Application, compiled into a dll

defs.h

namespace JJLibrary
{
    typedef void (__stdcall *MYCALLBACK) (bool mybool, int myint);
}

unmanaged_dll.h

#ifndef JJAPI_H
#define JJAPI_H

#ifdef UNMANAGED_EXPORTS
#define JJ_API __declspec(dllexport)
#else
#define JJ_API __declspec(dllimport)
#endif

#include "defs.h"

namespace JJLibrary
{
    JJ_API void U_helloWorld();
    JJ_API void U_setCallback( MYCALLBACK theCallback );
    JJ_API void U_runCallback();
}
#endif //JJAPI_H

unmanaged_dll.cpp

#include "unmanaged_dll.h"
#include <iostream>
using namespace std;

namespace JJLibrary
{

    MYCALLBACK m_callback = 0;

    JJ_API void U_helloWorld()
    {
        cout << "Unmanaged: Hello world" << endl;
    }

    JJ_API void U_setCallback( MYCALLBACK theCallback )
    {
        cout << "Unmanaged: Setting callback" << endl;
        m_callback = theCallback;
    }

    JJ_API void U_runCallback()
    {
        bool b = true;
        int  i = 25;
        cout << "Unmanaged: Running callback: " << b << " " << i << endl;
        if (m_callback)
            m_callback(b, i);
        // In the final application b and i are generated here after processing data, I give them values for testing
        // When they are generated, call the function in C#
    }   

}

Wrapper: C++ CLR Class Project

wrapper.h

#include "defs.h"
#include <iostream>

using namespace System;
using namespace System::Runtime::InteropServices;
using namespace JJLibrary;
using namespace std;

namespace wrapper { 

    public ref class Wrapper
    {

    public:

        void M_helloWorld();
        void M_setCallback( MYCALLBACK theCallback );
        void M_runCallback( bool mybool, int myint );

    };
}

wrapper.cpp

#include "stdafx.h"
#include "wrapper.h"
#include "defs.h"
#include <iostream>
using namespace wrapper;
using namespace JJLibrary;
using namespace std;

void Wrapper::M_helloWorld()
{
    cout << "Managed: Hello World" << endl;
    U_helloWorld();
}

void Wrapper::M_setCallback( MYCALLBACK theCallback )
{
    cout << "Managed: Setting callback" << endl;
    U_setCallback( theCallback);
}

void Wrapper::M_runCallback(bool mybool, int myint)
{
    cout << "Managed: Running callback" << endl;
    U_runCallback(mybool, myint);
}

And finally, Program.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;
using wrapper;

namespace CS
{
    class Program
    {

        void Test(bool mybool, int myint)
        {
            Console.WriteLine(!mybool);
            Console.WriteLine(2*myint);
        }


        static void Main(string[] args)
        {
            Wrapper myWrapper = new Wrapper();
            myWrapper.M_helloWorld();
            myWrapper.M_setCallback(Test);
            myWrapper.M_runCallback(true, 25);  // --> false 50

            string s = Console.ReadLine();  // Pause
        }
    }
}

Answer 1

Too much code to really understand, but my solution to a similar problem involved a delegate that looks like this.

[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate void UserFunctionCallback(IntPtr context, int nvalues,
  [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)]IntPtr[] values);

If that helps I can add some more code.