How to update array values from c++ dll while calling by reference in c# code?

Question

I am calling a function (named cbFunction) from a c++ dll using c# code. I have to pass array of strings (named strArray) ,from c# code, as arguments to c++ 'cbFunction'. Inside c++ function, I have to change the array's values. The newly changed values should be read back in c# code.

Problems I face:

1. The base address of strArray in c# and the one received in arguments in c++ dll are totally different.
2. I can read the array of strings in c++ dll. But, I have to modify the array's values inside c++ function. When I change those values in c++ function, the change is not reflected in c# code. `

C# code

public static class Call_API
{
   [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
   private delegate bool CallBackFunction(string[] argv, int argc);

   private static  string[] strArray;

   public static void ChangeValue()
   {
      IntPtr pDll = NativeMethods.LoadLibrary("DllFunctions.dll");
      IntPtr pAddressOfFunctionToCall = NativeMethods.GetProcAddress(pDll, "cbFunction");

      string args = "Hello Disney World";
      strArray = args.Split(' ');
      CallBackFunction cbFunction = ((CallBackFunction)Marshal.GetDelegateForFunctionPointer(
                                                  pAddressOfFunctionToCall, typeof(CallBackFunction));
      if(false == cbFunction(strArray, strArray.Count()))
      {
          //some task
      }
   }
}

c++ dll code (DllFunctions.dll) :

bool cbFunction(char** argv, int argc)
{
   //Some task

   char VarValue[256] = { 0 };
   std::string s = "Jetix";
   sprintf_s(VarValue, s.c_str());

   strcpy_s(argv[1], sizeof(VarValue), VarValue);
   return false;
}

Based on this code, my expected values at the end in strArray (in c#) are {"Hello", "Jetix", "World"}.

Thanks in advance!

Answer 1

First of all a char in c# is not the same as char in c++. You need an sbyte in c# which is the same as char in c++. We will use a byte for convenience. It works fine.

Code:

string args = "Hello Disney World";
string[] strArray = args.Split( ' ' );

byte[][] byteArray = new byte[ strArray.Length ][ ];

//convert string to byte array
for( int i = 0; i < strArray.Length; i++ ) {
    byteArray[ i ] = Encoding.ASCII.GetBytes( strArray[ i ] );
}

To get a byte**, you need a byte*[] ( More info Converting from a jagged array to double pointer in C# ):

unsafe
{
    GCHandle[] pinnedArray = new GCHandle[ byteArray.Length ];
    byte*[] ptrArray = new byte*[ byteArray.Length ];

    for( int i = 0; i < byteArray.Length; i++ ) {
        pinnedArray[ i ] = GCHandle.Alloc( byteArray[ i ], GCHandleType.Pinned );
    }

    for( int i = 0; i < byteArray.Length; i++ ) {
        ptrArray[ i ] = (byte *)pinnedArray[ i ].AddrOfPinnedObject();
    }

    fixed ( byte **ptr = &ptrArray[ 0 ] ) {
        IntPtr mptr = (IntPtr)ptr;

        if( false == cbFunction( mptr, strArray.Count() ) ) {
            //some task
        }

    }

    for( int i = 0; i < pinnedArray.Length; i++ )
        pinnedArray[ i ].Free();

}

Your declaration should be:

[UnmanagedFunctionPointer( CallingConvention.Cdecl )]
private delegate bool CallBackFunction( IntPtr argv, int argc );

EDIT

For completion there is an easier way to to do it ( Marshaling Data with Platform Invoke, Marshaling Different Types of Arrays ):

bool cbFunction(char *argv[], int argc)
{
    //Some task
    STRSAFE_LPSTR temp;
    const size_t alloc_size = sizeof(char) * 5; //"Jetix" num of characters

    temp = (STRSAFE_LPSTR)CoTaskMemAlloc( alloc_size );
    StringCchCopyA( temp, alloc_size, (STRSAFE_LPSTR)"Jetix" );

    CoTaskMemFree( argv[1] );
    argv[1] = (char *) temp;

    return false;
}

Call it:

string args = "Hello Disney World";
strArray = args.Split(' ');
CallBackFunction cbFunction = ((CallBackFunction)Marshal.GetDelegateForFunctionPointer(
                                pAddressOfFunctionToCall, typeof(CallBackFunction));

if( false == cbFunction(strArray, strArray.Count()) )
{
    //some task
}

And declaration:

[UnmanagedFunctionPointer( CallingConvention.Cdecl )]
public delegate bool CallBackFunction( [In, Out] String[] argv, int argc );