如何使用Pinvoke将二进制数据的缓冲区从C传递到C＃

Question

I have a DLL coded in C that has functions that output image data as unsigned char *, convert between different image formats and so on. I have a client who wants to make use of this from C#. I guess that the apppropriate data type on the C# side would be byte [].

I thought that PInvoke would help, but I cant find the appropriate technique to marshall this "binary data" to C# (whose variable length is stored in a separate variable). All the marshalling examples I have seen concern null terminated strings and an image array does not stop at an ascii null.

I have seen that I might alternatively consider passing the pointer to the data via an IntPtr but it looks like this would involve unsafe code on the C# side.

Answer 1

You want to allocate global memory, GlobalAlloc

Then in C#, you need to marshall the pointer to a managed type.

For a string I am using the following code, (you can adapt it to your needs):

 public static string GetString() {
        IntPtr str = mylib.getstring(); //get native pointer
        if (str == IntPtr.Zero)
            return null;

        string newStr = Marshal.PtrToStringAnsi(str); //marshall to managed string
        Marshal.FreeHGlobal(str); //free memory

        return newStr;
    }

Edit: Forgot to mention how to PInvoke your library:

class mylib {
   [DllImport("mylib.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
    public extern static IntPtr getstring();
}

Also don't forget to import System.Runtime.InteropServices

Answer 2

OK, George TG's answer set me on the right path, (thankyou!) but suppose that we have a function with signature void fillBytes(unsigned char *outBytes, int nbBytes); on the C side that writes nbBytes into the array at outBytes then the C#side could be written as this:

class Program
{
    [DllImport("FixedSizeString", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
    public static extern void fillBytes(IntPtr buffer, int nbBytes);
    void main(string[] args)
    {
        int BUFFSIZ = 256;// corresponds to the number of bytes in the buffer
        IntPtr iptr = Marshal.AllocHGlobal(BUFFSIZ);
        byte[] buffer = new byte[BUFFSIZ];
        if (iptr == IntPtr.Zero)
            Console.WriteLine("Allocation failed");
        else
        {
            fillBytes(iptr, BUFFSIZ);
            for (int i = 0; i < BUFFSIZ; ++i)
            {
                buffer[i] = Marshal.ReadByte(buffer, i);
            }
            Marshal.FreeHGlobal(iptr);
            // now deal with buffer here ...
        }
    }
}