将C ++函数包装为具有结构的总动态大小的c＃

Question

I'm struggling with wrapping C++ function to C#. I have very basic knowledge about these sort of wrapping but here i'm trying to find the "best solution".

Let's say I only have a .dll that contains C++ function. I only know there is a function with this signature :

static void GetInfos(LibraryInfo& infos);

And of course I know there is a class LibraryInfos

class LIBRARY_EXPORT_CLASS LibraryInfo
{
    public:
        const char* libVersion;
        const char* libName;
        const char* libDate; 
    };
};

Now I try to use this function in a C# test project :

static void Main(string[] args)
{
     // Create Pointer
     IntPtr ptr;

     // Call function
     GetInfos(out ptr);

     // Get the 100 first byte (used only to demonstrate)
     byte[] buffer = new byte[100];
     Marshal.Copy(ptr, buffer, 0, 100);

     // Display memory content
     Console.WriteLine(Encoding.ASCII.GetString(buffer));

     Console.ReadLine();
}

[DllImportAttribute("MyLibrary.dll", CallingConvention = CallingConvention.Cdecl, EntryPoint = "GetInfos")]
private static extern void GetInfos(out IntPtr test);

This code give me as output

v.1.2.5                                                                   ?I9               

• First : I know this is the really bad way of doing it, marshalling an arbitrary length as a byte[] is only here just for demonstration.
• Second : I only have the version, but if I'm calling the same dll from a C++ project, I have the 3 field with data.

• Third : Why did I use Marshal copy, and this arbitrary length of 100 ? Because I didn't succeed in calling PtrToStruct, here is what I tried :

   [StructLayout(LayoutKind.Sequential)] private struct LibInformation { public IntPtr Version; // I tried, char[], string, and IntPtr public IntPtr Name; public IntPtr Date; } static void Main(string[] args) { // Create Pointer IntPtr ptr; // Call function GetInfos(out ptr); if (ptr != IntPtr.Zero) { LibInformation infos = (LibInformation)Marshal.PtrToStructure(ptr, typeof(LibInformation)); } Console.ReadLine(); } 

  [DllImportAttribute("MyLibrary.dll", CallingConvention = CallingConvention.Cdecl, EntryPoint = "GetInfos")] private static extern void GetInfos(out IntPtr test);

Then I'm not able to retrieve my Version, Name and Date.

• If I use IntPtr in my struct, I dont have the length of the String so I can't realy marshal.Copy, nor PtrToStringAuto.
• If I use Char[] or string it doesn't work.

I think my issue is about not knowing the size of the final response. so my best option for now is to make C++ project, calling this function from there then wrap this struct in a better one , that I can Marshal on the other side (with Length of each member as other member).

Any thought ?

[EDITS 1 Based on jdweng comment]

[StructLayout(LayoutKind.Sequential)]
private struct LibInformation
{
    public IntPtr Version; // I tried, char[], string, and IntPtr
    public IntPtr Name;
    public IntPtr Date;
}

static void Main(string[] args)
{
    // Create Pointer
    IntPtr ptr;

    // Call function
    GetInfos(out ptr);

    var data = Marshal.PtrToStructure<LibInformation>(ptr);
    var version = Marshal.PtrToStringAnsi(data.Version);
    Console.WriteLine(version) // result : ""

    // Use Ptr directly as string instead of struct
    var version2 = Marshal.PtrToStringAnsi(ptr);
    Console.WriteLine(version2) // result : "v1.2.5" but how can i access other field ?

    Console.ReadLine();
}


[DllImportAttribute("MyLibrary.dll", CallingConvention = CallingConvention.Cdecl, EntryPoint = "GetInfos")]
private static extern void GetInfos(out IntPtr test);

[EDITS 2 Based on jdweng 2snd comment]

[StructLayout(LayoutKind.Sequential)]
private struct LibInformation
{
    public IntPtr Version;
    public IntPtr Name;
    public IntPtr Date;
}

static void Main(string[] args)
{
    // Create Pointer for my structure
    IntPtr ptr;

    // Create 3 pointers and allocate them
    IntPtr ptrVersion = Marshal.AllocHGlobal(100);
    IntPtr ptrName = Marshal.AllocHGlobal(100);
    IntPtr ptrDate = Marshal.AllocHGlobal(100);

    // Then declare LibInformation and assign
    LibInformation infos = new LibInformation();

    // Here is probably my missunderstanding (an my error)
    // As I need a ptr to call my function I have to get the Ptr of my struct
    IntPtr ptr = Marshal.AllocHGlobal(300);
    Marshal.StructureToPtr(infos, ptr, false);

    // Assign
    infos.Version = ptrVersion;
    infos.Name = ptrName;
    infos.Date = ptrDate;

    // Call function
    GetInfos(out ptr);

    var data = Marshal.PtrToStructure<LibInformation>(ptr);
    var version = Marshal.PtrToStringAnsi(data.Version);
    Console.WriteLine(version) // result : still ""

    Console.ReadLine();
}


[DllImportAttribute("MyLibrary.dll", CallingConvention = CallingConvention.Cdecl, EntryPoint = "GetInfos")]
private static extern void GetInfos(out IntPtr test);

Answer 1

I finally found the way to do it, thanks to the explanation of @jdweng and the link of @PaulF

The only bad news is that I have to arbitrary allocate n bytes before calling my functions

Link : MSDN : marshaling-classes-structures-and-unions

Explanations (jdweng):

The parameter list of a method is on the execution stack. Once you return from the method the parameters list is not valid because it can be over written by the parent code. Only the return value of a method is valid. So you have to Allocate all the data before calling the method. So you need to allocate the variables version, name, and date in unmangaged memory. Then declare LibInformation and set version, name, and date to the memory locations allocated. Finally call the method. Then to get the three variables you have to call Marshal.PtrToStruct to copy results from unmanaged memory.

Final code :

[StructLayout(LayoutKind.Sequential)]
private struct LibInformation
{
    public IntPtr Version;
    public IntPtr Name;
    public IntPtr Date;
}

static void Main(string[] args)
{
    // Create 3 pointers and allocate them
    IntPtr ptrVersion = Marshal.AllocHGlobal(100);
    IntPtr ptrName = Marshal.AllocHGlobal(100);
    IntPtr ptrDate = Marshal.AllocHGlobal(100);

    // Then declare LibInformation and assign
    LibInformation infos = new LibInformation();

    // Assign
    infos.Version = ptrVersion;
    infos.Name = ptrName;
    infos.Date = ptrDate;

    // Call function
    GetInfos(out infos);

    var version = Marshal.PtrToStringAnsi(data.Version);
    var name = Marshal.PtrToStringAnsi(data.Name);
    var date = Marshal.PtrToStringAnsi(data.Date);

    Console.ReadLine();
}


[DllImportAttribute("MyLibrary.dll", CallingConvention = CallingConvention.Cdecl, EntryPoint = "GetInfos")]
private static extern void GetInfos(out LibInformation test); // Changing IntPtr to LibInformation

[Edit 1 based on David Heffernan comment]

Here is the C code of a calling sample :

HComplexCTXPoint::LibraryInfo versionInfo;
HComplexCTXPoint::GetInfos(versionInfo);
std::cout << versionInfo.libName << std::endl;