(C#) AccessViolationException when getting char ** from C++ DLL

Question

I've written a basic C++ library that gets data from an OPC UA server and formats it into an array of strings (char **). I've confirmed that it works standalone, but now I'm trying to call it from a C# program using DLLs/pInvoke and running into serious memory errors.

My C# main:

List<String> resultList = new List<string>();
IntPtr inArr = new IntPtr();
inArr = Marshal.AllocHGlobal(inArr);
resultList = Utilities.ReturnStringArray(/*data*/,inArr);

C# Helper functions:

public class Utilities{

    [DllImport(//DllArgs- confirmed to be correct)]
    private static extern void getTopLevelNodes(/*data*/, IntPtr inArr);

    public static List<String> ReturnStringArray(/*data*/,IntPtr inArr)
    {

       getTopLevelNodes(/*data*/,inArr); // <- this is where the AccessViolationException is thrown
       //functions that convert char ** to List<String>
       //return list
    }

And finally, my C++ DLL implementation:

extern "C" EXPORT void getTopLevelNodes(*/data*/,char **ret){

std::vector<std::string> results = std::vector<std::string>();
//code that fills vector with strings from server

ret = (char **)realloc(ret, sizeof(char *));
ret[0] = (char *)malloc(sizeof(char));
strcpy(ret[0], "");
int count = 0;
int capacity = 1;

for (auto string : results){
        ret[count] = (char*)malloc(sizeof(char) * 2048);
        strcpy(ret[count++], string.c_str());
        if (count == capacity){
                capacity *= 2;
                ret = (char **)realloc(ret, sizeof(char *)*capacity + 1);
        }
}

What this should do is, initialize a List to hold the final result and IntPtr to be populated as a char ** by the C++ DLL, which is then processed back in C# and formatted into a List. However, an AccessViolationException is thrown every time I call getTopLevelNodes from C#. What can I do to fix this memory issue? Is this the best way to pass an array of strings via interop?

Thank you in advance

Edit: I'm still looking for more answers, if there's a simpler way to implement string array interop between C# and a DLL, please, let me know!

Answer 1

METHOD 1 - Advanced Struct Marshalling.

As opposed to marshalling a list, try creating a c# struct like this:

[StructLayout(LayoutKind.Sequential, Pack = 2)]
public struct StringData
{
    public string [] mylist; /* maybe better yet byte[][] (never tried)*/
};

Now in c# marshall like this:

IntPtr pnt = Marshal.AllocHGlobal(Marshal.SizeOf(StringData)); // Into Unmanaged space

Get A pointer to the structure.

StringData theStringData = /*get the data*/;
Marshal.StructureToPtr(theStringData, pnt, false);
                                    // Place structure into unmanaged space.

getTopLevelNodes(/* data */, pnt); // call dll

theStringData =(StringData)Marshal.PtrToStructure(pnt,typeof(StringData));
                                    //get structure back from unmanaged space.
Marshal.FreeHGlobal(pnt); // Free shared mem

Now in CPP:

#pragma pack(2)
/************CPP STRUCT**************/
struct StringDataCpp
{
    char * strings[]
}; 

And the function:

extern "C" EXPORT void getTopLevelNodes(/*data*/,char *ret){ //just a byte pointer.   

struct StringDataCpp *m = reinterpret_cast<struct StringDataCpp*>(ret);

//..do ur thing ..//

}

I have used this pattern with much more complicated structs as well. The key is that you're just copying byte by byte from c# and interpreting byte by byte in c++.

The 'pack' is key here, to ensure the structs align the same way in memory.

METHOD 2 - Simple byte array with fixed

    //USE YOUR LIST EXCEPT List<byte>. 
        unsafe{
           fixed (byte* cp = theStringData.ToArray)
             {

                getTopLevelNodes(/* data */, cp)
    /////...../////

//SNIPPET TO CONVERT STRING ARRAY TO BYTE ARRAY
    string[] stringlist = (/* get your strings*/);
    byte[] theStringData = new stringlist [stringlist .Count()];
     foreach (string b in parser)
     {
// ADD SOME DELIMITER HERE FOR CPP TO SPLIT ON?
          theStringData [i] = Convert.ToByte(stringlist [i]);
          i++;
     }

NOW

CPP just receives char*. You'll need a delimiter now to seperate the strings. NOTE THAT YOUR STRING PROBABLY HAS DELIMETER '\0' ALREADY USE A REPLACE ALGORITHM TO REPLACE THAT WITH a ';' OR SOMETHING AND TOKENIZE EASILY IN A LOOP IN CPP USING STRTOK WITH ';' AS THE DELIMITER OR USE BOOST!

OR, try making a byte pointer array if possible.

Byte*[i] theStringStartPointers = &stringList[i]/* in a for loop*/
fixed(byte* *cp = theStringStartPointers) /// Continue

This way is much simpler. The unsafe block allows the fixed block and the fixed ensures that the c# memory management mechanism does not move that data.