使用引用类型作为参数从c＃调用c ++函数

Question

 int Set(CANMsg &CANObj)

I have to call the method above, from c#. Untill now i have defined a wrapper :

 extern "C" __declspec(dllexport) int SetWrapper(CANMsg CANObj);

CANMsg CANObj --- is this parameter ok or should i use CANMsg *CANObj ?

and here i implement the wrapper:

 extern "C" __declspec(dllexport) int SetWrapper(CANMsg CANObj)
 { 
      return Set(CANObj);
 }

I am creating this wrapper because this is an overloaded version of the function and i had to make a difference somehow.

Here is the CANMsg class:

 class CANMsg
 {
 public:
 CANMsg();
 ~CANMsg();

 void AddRef() const;
 void Release() const;
 unsigned int MsgId;
 unsigned int DLC;
 unsigned int Handle;
 unsigned int Interval;
 unsigned int TimeStamp;
 unsigned char Data0;
 unsigned char Data1;
 unsigned char Data2;
 unsigned char Data3;
 unsigned char Data4;
 unsigned char Data5;
 unsigned char Data6;
 unsigned char Data7;

  protected:

mutable int refCount;  

};

Now, in C# i have the following :

      [StructLayout(LayoutKind.Sequential)]
      public class CANmsg
   {
      public  int MsgId;
      public int DLC;
      public int Handle;
      public int Interval;
      public int TimeStamp;
      public char Data0;
      public char Data1;
      public char Data2;
      public char Data3;
      public char Data4;
      public char Data5;
      public char Data6;
      public char Data7;
   }

and the import is like this :

     [DllImport("engine.dll", CallingConvention = CallingConvention.Cdecl)]
  [return: MarshalAs(UnmanagedType.I4)]
  public static extern int SetWrapper(IntPtr canMSGObject);

I am a bit confused about that CANMsg object, am I declaring it ok as an IntPtr, is the marshal ok, or the types ? If i let it like so, with the IntPtr, what kind of instantiation should i perform there? If i send a CANMsg object, i get an error regarding some invalid arguments.

Let me know if you need some more details about this.

Answer 1

You can not pass a C# object to native C++ like this. Marshal.StructureToPtr is what you need, the details and examples are here

Answer 2

When I see your C++ class definition, I ask myself "what happens in the constructor and the destructor?" and "what do AddRef() and Release() do?" These are important questions because you can't simply project data from a C# object onto that IntPtr and hope for the best. Instead, you should think about making a helper dll that does this work for you. You might need methods something like this:

public ref class MyLibraryHelper {

public:
    IntPtr MakeCANMsg() { return gcnew IntPtr(new CANMsg()); }
    void DestroyCANMsg(IntPtr msgPtr) {
       CANMsg *msg = reinterpret_cast<CANMsg *>(msgPtr.ToPointer());
       if (msg) delete msg;
    }
    void ProjectTo(CSharpCANMsg ^csh, IntPtr msgPtr)
    {
       CANMsg *msg = reinterpret_cast<CANMsg *>(msgPtr.ToPointer());
       if (!msg) return;
       msg->MsgId = csh->get_MsgId();
       // etc
    }
    void ProjectFrom(IntPtr msgPtr, CSharpCANMsg ^csh)
    {
       CANMsg *msg = reinterpret_cast<CANMsg *>(msgPtr.ToPointer());
       if (!msg) return;
       csh->set_MsgId(msg->MsgId);
       // etc
    }
}

My C++/CLI is rusty, so expect some issues. If this looks like hand-marshalling, well, it is because given the class that you've exposed, it seems like you need it.

Now honestly, you probably don't want this. Really, you want a C++/CLI class that constructs a CANMsg and keeps it as a private member and then maps .NET properties onto the lower level object. This type of class will have to be disposable and the !ClassName() destructor will be responsible for deleting the underlying object.