Wrapping C# C++

Question

I would like to wrap a native library with C++/CLI. It's work with primitive type. But in the following case, it's more complicated :

interface ISampleInterface
{
    void SampleMethod();
}

public ref class NativeClassWrapper {
    NativeClass* m_nativeClass;

public:
    NativeClassWrapper() { m_nativeClass = new NativeClass(); }
    ~NativeClassWrapper() { delete m_nativeClass; }
    void Method(ISampleInterface ^i) {
        ???
        m_nativeClass->Method(i);
    }
};

How to wrap this ? Because the native code C++ doesn't know the ISampleInterface type... (Same question with a virtual class)

Thanks you.

Why does NativeClass::Method need access to ISampleInterface? As you noted, it can't use it, so you need a way to change the design. — SteveLove
– SteveLove, Commented Aug 1, 2013 at 12:35
The native code needs to access to a class which implements ISampleInterface. In this example, it's an interface, but it can be a class. The problem in this design is the native code doesn't know the type of the element manipulated by C++/CLI. I have no idea how to resolve this problem. Which does design use ? Thanks for your help. — user1886318
– user1886318, Commented Aug 1, 2013 at 12:49

Hans Passant · Accepted Answer · 2013-08-01 14:33:47Z

2

There are some mistakes in the code snippet. Let's start with a clean example, declaring the native class first:

#pragma unmanaged
class INativeInterface {
public:
    virtual void SampleMethod() = 0;
};

class NativeClass {
public:
    void Method(INativeInterface* arg);
};

And the managed interface:

#pragma managed
public interface class IManagedInterface
{
    void SampleMethod();
};

So what you need is a native wrapper class that derives from INativeInterface so that you can pass an instance of it to NativeClass::Method(). All that this wrapper has to do is simply delegate the call to the corresponding managed interface method. Usually a simple one-liner unless argument types need to be converted. Like this:

#pragma managed
#include <msclr\gcroot.h>

class NativeInterfaceWrapper : public INativeInterface {
    msclr::gcroot<IManagedInterface^> itf;
public:
    NativeInterfaceWrapper(IManagedInterface^ arg) : itf(arg) {};
    virtual void SampleMethod() {
        itf->SampleMethod();
    }
};

Now your method implementation becomes easy:

void Method(IManagedInterface^ i) {
    NativeInterfaceWrapper wrap(i);
    m_nativeClass->Method(&wrap);
}

edited Aug 1, 2013 at 14:33

answered Aug 1, 2013 at 13:16

Hans Passant

946k151 gold badges1.8k silver badges2.6k bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

user1886318 Over a year ago

Thanks you very much, it works fine. Do you know the equivalent of msclr::gcroot in JAVA ?

Ben Voigt Over a year ago

@user1886318: It looks like jobject is roughly equivalent to GCHandle, and you'd need to make your own RAII wrapper around that to make sure it automatically gets released when the native code no longer needs it. Or borrow one, but I don't think there's an official JNI-sanctioned wrapper.

Jochen Kalmbach · Accepted Answer · 2013-08-01 14:00:14Z

2

If your native class needs to callback into .NET code, you need to use the gcroot template. Wuth this you can store the managed object in an unmanaged class. In this unmanaged class you can then use a native "callback" and then use the member stored in `gcroot´ to callback into managed code (ISampleInterface).

1 Comment

user1886318 Over a year ago

Thanks you, indeed I have to use gcroot.

Collectives™ on Stack Overflow

Wrapping C# C++

2 Answers 2

2 Comments

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

2 Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related