C++/CLI wrapper for native C++ dll

Question

I have written an C++/Cli wrapper for a native C++ dll, but when I call some method from C# I get an System.AccessViolationException error in my C++/Cli Wrapper dll! It's necessary to marshal the unmanaged types or something else?!

// Wrapper.h

typedef UnmanagedClass* (*Instance)(void);

private:
    UnmanagedClass *m_object; // unmanaged object   

// Wrapper.cpp

Wrapper:Wrapper()
{
    HINSTANCE unmanagedLib;
    unmangedLib = LoadLibrary(SystemStringToLPCSTR(dllPath+dllName));

    // load instance
    Instance _createInstance = (Instance)GetProcAddress(unmangedLib, "GetInstance");
    m_object = (_createInstance)(); 
}

Wrapper::~Wrapper()
{
    m_object->~UnmanagedClass();
}


Uint32 Wrapper::SomeMethod(Uint8 *bytRecvBuffer, int &iRecvLen)
{
    return m_object->SomeMethod(bytRecvBuffer, iRecvLen);
}

// Unmanaged Class

class UnmanagedClass    
{
public:
    /**
    * Default constructor. 
    */
    UnmanagedClass(void);
    /**
    * Default Destructor
    */
    ~UnmanagedClass(void);

    virtual Uint32 Wrapper::SomeMethod(Uint8 *bytRecvBuffer, int &iRecvLen);
};

// export the UnmanagedClass object
extern "C" _declspec(dllexport) UnmanagedClass* GetInstance();

// UnamangedClass.cpp

UnamangedClass::~UnamangedClass(void)
{
    if (UnamangedClassDLL != NULL)
        FreeLibrary(UnamangedClassDLL);

    UnamangedClassDLL = NULL;
}

extern "C" _declspec(dllexport) UnmanagedClass* GetInstance()
{

    return new UnmanagedClass();
}

When I call at example SomeMethod from C# I get the error in C++/Cli dll! (I included the C++/cli dll with add reference in C sharp project and create the Wrapper object)

Thank you for your help!

greets

It's necessary to marshal the unmanaged types or something else? How can we possibly know when you don't show the definitions of UnmanagedClass or Wrapper? (BTW, m_object->~UnmanagedClass(); looks absolutely wrong.) — ildjarn
I don't think this is wrong (read it here ondotnet.com/lpt/a/4731 -> I write the wrapper with this tutorial) — leon22
@leon22 : Again, we can't know that for sure since we can't see the definitions of UnmanagedClass and Wrapper. — ildjarn
@leon22 : What is the implementation of GetInstance? Specifically, how does it allocate and construct an UnmanagedClass instance in a manner that you would think it appropriate to call its destructor directly and then not actually deallocate any memory? — ildjarn

ildjarn ildjarn · Accepted Answer · 2011-05-26T08:19:49

It is inappropriate to directly call the destructor of an object that was allocated with (non-placement) new. Try changing

m_object->~UnmanagedClass();

to

delete m_object;
m_object = 0;

(m_object = 0; is necessary because unlike a native C++ type's destructor, which may only be called once, an managed type's Dispose implementation may be called repeatedly, and doing so must have defined behavior.)

Or, better yet, in addition to exposing a GetInstance function, also expose a DestroyInstance function and call that instead of using delete so that consuming code does not need to depend on the implementation details of GetInstance (i.e., that it allocates its instance using operator new).

C++/CLI wrapper for native C++ dll

2 Answers