从 C++ 到 C# 中的 VARIANT 编组 safearray 的 safearray

Question

I'm trying to call a function in .NET from a native library, like this:

typedef int (WINAPI* TGetAllObjects)(int hModel, VARIANT& objects);

If you call it in the C++ client, the debugger shows that objects are a safearray of VARIANT , and each VARIANT is a safearray of BSTR .

I tried to implement as follows in C#:

public delegate TRetCode TGetAllObjects(int hModel, 
    [Out,In,MarshalAs(UnmanagedType.SafeArray, SafeArraySubType = VarEnum.VT_VARIANT )] ref MyStruct[] objects);

[StructLayout(LayoutKind.Sequential)]
public struct MyStruct
{
    [MarshalAs(UnmanagedType.SafeArray, SafeArraySubType = VarEnum.VT_BSTR)]
    public string[] Objects;
}

When calling the method, it gives an error:

System.Runtime.InteropServices.SafeArrayTypeMismatchException: "Specified array was not of the expected type."

Please tell me how to properly organize data marshalling in such a situation.

Answer 1

Try:

[UnmanagedFunctionPointer(CallingConvention.StdCall)]
delegate int TGetAllObjects(int hModel, ref object objects); 

and see EXACTLY what you receive. The objects variable is a VARIANT , not a SAFEARRAY . The VARIANT& objects contains the SAFEARRAY , it isn't a SAFEARRAY .

Then inside your code you can check its type and cast it.

Ah and note the CallingConvention ( WINAPI is StdCall ).

I've made some tests and it seems the basic VARIANT "container" is passed correctly. I'll say the truth, I consider a SAFEARRAY of VARIANT that are SAFEARRAY s of BSTR a weapon that should be included in the banned list by the Geneva Convention.

Some more tests make me think that my solution is the easyest one. I wasn't able to accept/pass directly a object[] or a string[] , and the received objects is a object[] where each element is a string[] . Something like:

var objects = new object[] { new string[] { "A", "B" }, new string[] { "C", "D" } };

Your "casting" problem

SAFEARRAY can have the index of the first element != 0 (this to support VB that uses 1-based arrays, arrays, where the first element is 1). .NET does support this in the category "strange arrays". Multidimensional arrays ( string[1, 2] ) and non-0 based arrays are in this category, and they are a pain to handle. Non-zero based arrays more so.

Code to convert the array in your case (where with "convert" I mean: copy it to a standard .NET array of arrays):

object[] castedObjects = (object[])objects;
string[][] strings = new string[castedObjects.Length][];

for (int i = 0; i < castedObjects.Length; i++)
{
    Array ar = (Array)castedObjects[i];
    string[] ar2 = new string[ar.Length];
    Array.Copy(ar, ar2, ar2.Length);
    strings[i] = ar2;
}