如何將const unsigned char *從c ++傳遞給c＃

Question

所以我在非托管c ++中有一個函數，當一些文本恰好“到達”時會被調用：

#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是一個在C＃DLL中定義的靜態函數，它應該采用一個類型的參數？

Body包含一系列長度為BodyLen的字符（文本）。

顯然有一些編組要做，但我不知道怎么做。

請幫忙。

Answer 1

下面的代碼描述了通過PInvoke在托管C＃代碼和非托管C / C ++ DLL之間進行通信的情況。 基本上這個想法是，您可以將C代碼傳遞給C＃委托。 const unsigned char*轉換為Marshal.PtrToStringAnsi的string 。

C ++：

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);
  }
}

C＃：

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 2

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將采用一個字符串。

Answer 3

我最終使用了Danvil的方法。 我將C代碼包裝在C ++ DLL中，然后我創建了另一個引用C ++ dll的C＃dll，並在托管代碼中公開了我想要的功能。 所以這里是：

C ++ DLL：

.h文件

 // 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文件

 // 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
    }        
 }