How to pass const unsigned char * from C ++ to C #

Question

So, I have a function in unmanaged C ++ that gets called when some text “arrives”:

#using <MyParser.dll>
...
void dump_body(const unsigned char *Body, int BodyLen) 
{
  // Need to pass the body to DumpBody, but as what type?
     ...
  MyParser::Parser::DumpBody(???);
}

DumpBody - static function defined in c # dll that should accept one type parameter?

The body contains an array of characters (text) of length BodyLen.

Obviously there is something here, but I have no idea how to do this.

Please, help.

Answer 1

void dump_body(const unsigned char *body, int bodyLen)
{
    // you might want a different encoding...
    String ^str = gcnew String((sbyte*)body, 0, bodyLen, gcnew ASCIIEncoding);
    MyParser::Parser::DumpBody(str);
}

DumpBody will take a string.

Answer 2

# C/++ DLL PInvoke. , , C- #. const unsigned char* string Marshal.PtrToStringAnsi.

++:

typedef void FncFoo (const char*);

FncFoo callback = 0;    

extern "C" {
  // this function is called from C# to pass the delegate
  void TakeFooCallback(FncFoo f) {
    callback = f;
  }
}

// C function calling C#
void dump_body(const unsigned char *Body, int BodyLen) {
  if(callback) {
    callback(Body);
  }
}

#:

class StringC2CS {

  delegate void DlgFoo(IntPtr a);

  [DllImport("myclib.dll")] // name of the dll
  void TakeFooCallback(DlgFoo callback);

  // this function gets called by C
  void FooImpl(IntPtr a) {
    string str = Marshal.PtrToStringAnsi(a);
    // use string
  }

  public StringC2CS() {
    // passes a callback to C
    TakeFooCallback(new DlgFoo(FooImpl));
  }
}

Answer 3

I ended up using Danvil . I wrapped the C code in a C ++ dll, and then created another C # dll that referenced the C ++ dll and revealed the functionality I wanted in managed code. So here it is:

C ++ dll:

.h file

 // Definition of a callback function to be called when some data arrives
 typedef void (*FncDlg) (const unsigned char*, int len);

 // Declaration of the function that will be exposed in managed code. 
 // The managed code will use this function to pass in a delegate
 extern "C" __declspec(dllexport) void AttachCallback(FncDlg f);

 // Declaration of a function that receives data and passes it to managed code
 void PassData(const unsigned char *Body, int BodyLen);

.cpp file

 // Instantiate a global function pointer to nothing
 void (*callback)(const unsigned char*, int len) = 0; 

 // This is called by C# to pass in a delegate
 void AttachCallback(FncDlg f) 
 {
    // Save delegate globally (to be triggered later when we receive data)
    callback = f;
 }

 // This is the function called when data is read from the socket
 void PassData(const unsigned char *Body, int BodyLen)
 {
    if(callback) {
    callback(Body, BodyLen);
    }
 }

C # dll:

 public static class Parser
 {
    public delegate void DlgDumpTipData(IntPtr a, int len);

    [DllImport("C++ dll name here", EntryPoint = "AttachCallback", ExactSpelling = true)]
    public static extern void AttachCallback(DlgDumpTipData callback); 

    public static int ConnectAndStartReceive(...)
    {
       // Attach a callback function (called when a message is received from data feed)
       AttachCallback(DumpDataCalback);
       ...
    }

    public delegate void MsgHandler(string msg);
    // When data arrives from the C library, this event passes it on to C# clients 
    public static event MsgHandler OnMessageArrived = delegate { };

    public static void DumpDataCalback(IntPtr ptr, int len)
    {
       //string str = Marshal.PtrToStringAnsi(ptr); 
       string dumpData;
       sbyte[] byteArr = new sbyte[len];
       for (int i = 0; i < len; i++)
       {
          // WARNING: if byte > 127 we have a problem when casting from Byte to SByte
          // In this case there is no problem, tested with values over 127 and it
          // converts fine to Latin-1 using the String overload 
          byteArr[i] = (sbyte)Marshal.ReadByte(ptr, i); 
       }

       unsafe
       {
         fixed (sbyte* pbyteArr = byteArr) // Instruct the GC not to move the memory
         {
             dumpData = new String(pbyteArr, 0, len, Encoding.GetEncoding("ISO-8859-1"));
         }
       }

       // Send data to whoever subscribes to it
       OnMessageArrived(dumpData);
       GC.Collect(); // This slows things down but keeps the memory usage low
    }        
 }