C＃无法执行带有内存集的C ++ DLL

Question

I am building a c++ lib for c#. However my program died when there was memset or memcpy inside. below is the code:

c#

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using System.Runtime.InteropServices;

    namespace CsharpCallDll
    {
        public class dllfunction
        {
            [DllImport("dllgen.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
            public static extern int calData(ref double data, int data_size, 
                ref double info, int info_size, ref char result,int max_result_size,ref int realResultSize);
        }

        class Program
        {
            static void Main(string[] args)
            {
                int data_size = 2;
                double[] data = new double[data_size];

                int info_size = 3;
                double[] info = new double[info_size];

                int max_result_size = 1000;
                char[] result = new char[max_result_size];

                int real_result_size = 0;

                data[0] = 1;
                data[1] = 2;
                info[0] = 1;
                info[1] = 2;
                info[2] = 3;

                unsafe
                {
                    dllfunction.calData(ref data[0], data_size,
                             ref info[0], info_size, ref result[0], max_result_size,ref real_result_size);

                    Console.Write(result + "\n");
                }
                Pause();
            }

            public static void Pause()
            {
                Console.Write("Press any key to continue . . . ");
                Console.ReadKey(true);
            }
        }
    }

c++

    MG_API int calData(double *data, int dataSize,
    double *info, int infoSize, char* result, int maxresultSize, int* realResultSize)
{       
    int errorCode = 0;

    if (dataSize == 0 || infoSize == 0)
    {
        errorCode = 1;
    }

    string resultArray = "";
    double* tempvalue = new double;
    string isnormal;
    string abnromaltype;
    int resultSiz = 0;


    for (int i = 0; i < 15; i++)
    {
        srand((int)time(NULL)+i);
        *tempvalue = (double)Random(10);
        if (*tempvalue > 8) {
            isnormal = "false";
            abnromaltype = abnromalTypeS[0];
        }else if (*tempvalue < 2) {
            isnormal = "false";
            abnromaltype = abnromalTypeS[1];
        }else{
            isnormal = "true";
            abnromaltype = abnromalTypeS[2];
        }

        resultArray = appendResultIntoString(resultArray, dataNameS[i], *tempvalue,
            dataUnitS[i], isnormal, abnromaltype);
    }

    *realResultSize = resultArray.size();
    // print the result
    cout << "this is the resultsize ";
    cout << *realResultSize << endl;
    // result = (char*) malloc(*resultSize);
     memset(result, 0, maxresultSize);
    // memcpy(result, resultArray.c_str(), *realResultSize);

    delete tempvalue;
    return errorCode;
}

resultArray is a string result.

My qeustion is: 1. when there is memcpy, memset in the c++ code, c# program will die there. what happened?

By the way: 2. is there a way to send a dynamic length string from c++ to c# 3. is there a way to send string[] from c++ to c#

Thank you guys!

Answer 1

..., ref char result,int max_result_size,ref int realResultSize

The char* parameter is ambiguous in C and C++. Could mean a reference to a single char (ref char in C#) or a reference to an array (char[] in C#). That doesn't matter much in those languages, although you can certainly get it wrong the exact same way you got it wrong here, but it makes a big, big difference in C#. You get it wrong in C by passing a char& instead of a char[]& and the memset() call will corrupt the stack of the caller. Same thing happens here.

Since the pinvoke marshaller doesn't know that it should actually pass an array reference, and the char type is not compatible with C code since it is 2 bytes in C# and 1 byte in C, the marshaller makes a copy of the single char to convert it to byte. Your memset() call now corrupts the memory allocated by the pinvoke marshaller for that single byte. Outcome is quite unpredictable, you only get an AVE if you're lucky.

Something else it does not know is that it must copy the array back. Beyond not knowing it is an array, it also doesn't know its length. And you have to ask for it, by default the pinvoke marshaller doesn't copy arrays back to avoid the cost of doing so.

Telling the pinvoke marshaller that it is an array that needs to be copied back looks like this:

..., [Out][MarshalAs(UnmanagedType.LPArray, SizeParamIndex(6)] char[] result

The [Out] attribute asks for array elements to be copied back, the SizeParamIndex property says where to look when the marshaller needs to know how many elements need to be copied.

It is both simpler and more efficient by not forcing the pinvoke marshaller to convert the array elements:

..., byte[] result

No longer a need to help with the [Out] and [MarshalAs] attribute. Since no conversion is required anymore, the pinvoke marshaller can simply pin the array and pass a pointer to its first element. Your C code now writes directly to the GC heap storage. Good thing you have the max_result_size argument, it is very important to avoid GC heap corruption. Be sure to pass the array's Length property.

Note that the same story applies to the data and info parameters. Not nearly as fatal since they don't require conversion. Declare them as double[] instead, no ref.

Answer 2

In addition to Hans Passant's advice, another possibility is to explicitly pin variables with the fixed statement.

unsafe
{
    fixed (double* d = data)
    {
        fixed (double* i = info)
        {
            fixed (int* rs = &real_result_size)
            {
                dllfunction.calData((IntPtr)d, data_size, (IntPtr)i, info_size, result, max_result_size, (IntPtr)rs);
            }
        }
    }
}