Weblog of Gopalakrishna Palem : Marshalling

How to check if my code is executing inside a Managed App or Native App?

P.Gopalakrishna — Fri, 29 Feb 2008 21:56:00 GMT

If you check the CRT source code (inside VC\crt\src\crt0.c ) you can find an interesting function check_managed_app() that returns 1 if managed app, 0 if not based on the COM Runtime Descriptor in the Image Data Directory of the PE or PE+ header. You...(read more)

How to return String-Arrays from C++ COM component to C#?

P.Gopalakrishna — Fri, 27 Apr 2007 19:43:00 GMT

Want to return an array of strings from native COM component to managed code?

You need to declare the string array as SAFEARRAY(VARIANT) in the COM code.

IDL for the function that returns the array of strings for the COM component would look like,

[id(1)] HRESULT GetStringArray([out] SAFEARRAY(VARIANT)* StrArray);

The C++ implementation of the function should create a Safe Array of variants and initialize each variant with a BSTR as shown below:

STDMETHODIMP CNativeCOMComponent::GetStringArray(SAFEARRAY** pStrArray) 
{ 
      SAFEARRAYBOUND bounds[] = {{2, 0}};  //Array Contains 2 Elements starting from Index '0' 

      SAFEARRAY* pSA = SafeArrayCreate(VT_VARIANT,1,bounds); //Create a one-dimensional SafeArray of variants

      long lIndex[1]; 

      VARIANT var; 

            lIndex[0] = 0; // index of the element being inserted in the array 

            var.vt = VT_BSTR; // type of the element being inserted 
          
            var.bstrVal = ::SysAllocStringLen( L"The First String", 16 ); // the value of the element being inserted 

            HRESULT hr= SafeArrayPutElement(pSA, lIndex, &var); // insert the element 

            // repeat the insertion for one more element (at index 1) 

            lIndex[0] = 1; 

            var.vt = VT_BSTR; 

            var.bstrVal = ::SysAllocStringLen( L"The Second String", 17 ); 

            hr = SafeArrayPutElement(pSA, lIndex, &var); 

      *pStrArray = pSA; 

      return S_OK; 
}

In the above sample we are inserting two BSTR variants into the created Safe Array. Once the Array is filled with the variants (of type VT_BSTR), it can be retrieved from the C# managed code as shown below:

{ 
     CNativeCOMComponent ComObj = new CNativeCOMComponent(); 

     Array arr; 

     ComObj.GetStringArray(out arr); //arr would now hold the two strings we have sent from the COM code 
}

How to Modify Managed Strings in Native Code?

P.Gopalakrishna — Thu, 01 Mar 2007 20:52:00 GMT

Want to modify a managed string passed to a native function? I collected two ways of doing it. Either you can use System::Text::StringBuilder mechanism or you can use the array method mentioned at http://msdn2.microsoft.com/en-us/library/s04yfy1s(VS.80).aspx

You can pass the string that you want to modify as a one-element string array to the native code and modify the array, or you can pass a StringBuilder variable and modify it.

In the array mechanism, construct a native function that looks like below:

void NativeFunction(PWSTR lpszString[])
{
lpszString[0] = L"Hello World"; // Modifies the string
}

The managed code to P/Invoke this should be as below:

    class Program
    {
        [DllImport("NativeDll.dll")]
        static extern int NativeFunction([In][Out][MarshalAs(UnmanagedType.LPArray,ArraySubType=UnmanagedType.LPWStr, SizeConst=1)] String[] str);

        static void Main(string[] args)
        {
            String[] myArr = new String[] { "One" };

NativeFunction(myArr); // Call the Native Method

            System.Console.WriteLine(myArr[0].ToString()); // Should Print "HelloWorld"
        }
    }

In the above, we are DllImporting the native function by marshalling the parameter as an in,out,LPWStr array of size 1.

Note that this requires declaring the native function parameter as an array of strings (instead of single string). This should be fine as long as we have the flexibility to change the native function prototype. If the native function is an API Callback (e.g. GetWindowText) then we cannot use this method.

In such cases using StringBuilder is the recommended approach. If we have a native method declaration as below,

void GetComputerName (PWSTR lpszString, int nBufLen)
{
wcsncpy(lpszString, L"Home-PC", nBufLen); // Modifies the string
}

In the managed code, use the following DllImport options:

[DllImport("NativeDll.dll")]
static extern void GetComputerName ([In][Out][MarshalAs(UnmanagedType.LPWStr)] StringBuilder str, [In] int nBufLen);

        static void Main(string[] args)
        {
            StringBuilder ComputerName = new StringBuilder();

ComputerName.EnsureCapacity(1024);

fnWin32DLL(ComputerName, 1024); // Call the Native Method

System.Console.WriteLine(ComputerName.ToString()); // Should Print "Home-PC"
}

In the managed code, declare the string parameter as an In,Out, StringBuilder and pass a StringBuilder variable (after ensuring a minimum buffer size with EnsureCapacity() function to avoid buffer access problems in the native code).