On Apr 26, 1:16 pm, "Willy Denoyette [MVP]"
<willy.denoye...@telenet.be> wrote:

Willy,

For P/Invoke, I do the following on the managed side:

// used to shuttle the data to the unmanaged world
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
public struct SomeBuffer
{
   public IntPtr data;
   public int len;
}

[DllImport("Unmanaged.dll", CharSet = CharSet.Ansi)]
  public static extern void SaveData(string name, ref SomeBuffer
data);

I then allocate the buffer ala:

       SomeBuffer CreateBuffer(byte[] value)
       {
           SomeBuffer sb = new SomeBuffer();
           sb.length = data.Length;
           sb.buffer = Marshal.AllocHGlobal(sb.length);
           Marshal.Copy(value, 0, sb.buffer, sb.length);

           return sb;
       }

and invoke SaveData() with a created SomeBuffer to house the value
byte array.

For C++ Interop, on the managed (c++/cli) side, the function is:

void SaveData( String^ name, array<byte>^ value)
{
       localName =
(char*)Marshal::StringToHGlobalAnsi(name).ToPointer();  // marshal the
name
    pin_ptr<byte> ptr = &value[0];  // pin the value buffer

    SomeBuffer sb;

    sb.buffer = (void*)ptr;
    sb.length = bytes.Length;

    unmanagedImpl->SaveData( localName, &sb);  // issue the unmanaged
call

       Marshal::FreeHGlobal(IntPtr(localName));  // free the
marshalled string buffer
}

Assume the unmanaged SaveData method copies the incoming SomeBuffer
data to process in both approaches and that the prototype is:

void SaveData (LPCSTR name, SomeBuffer* value);

Thanks