Marshalling VARIANT across ABI boundaries in a WinRT component - c++

Question

I am porting our component which is written in C++ at its core and has both an ActiveX and a .Net shell. The component internally uses the VARIANT type in many places. Some public properties (get/set) and methods of this component's arguments are of the VARIANT type in the ActiveX implementation and System::Object in the .Net implementation. Internally in our code we use the VARIANT directly.
When implementing the ActiveX component, I did not need to do any marshaling since VARIANT is an OLE/COM type.
When implementing .Net component, I used similar to this:
VARIANT var;
//...
//Initialize the VARIANT value
//...
System::IntPtr p( &var );
System::Object ^o = System::Runtime::InteropServices::Marshal::GetObjectForNativeVariant(p );
return o;
In WinRT, there does not seem to be any similar Marshal class that will do the job. According to MSDN "The WinRT Platform::Runtime::InteropServices namespace is intended for internal use only, and is not intended to be used for development."
What are my options? Surely there must be an existing class to do the work of marshalling a VARIANT across ABI boundaries. I don't want to write such a marshaller and then find out that it already exists !
Any help would be much appreciated.

Answer 1

Thanks for your reply. I ended up writing a utility class using Windows::Foundation::IPropertyValue.
I posted the code here together with a link back to this thread:
Marshalling a VARIANT in a WinRT component
Example:
// in a C# we can write:
string [] sarray = new string[2];
sarray[0] = "abc";
sarray[1] = "def";
SetValue(sarray);
//in C++/CX we write:
void SetValue( Object ^value )
{
VARIANT var;
VariantInit( &var );
var = acMarshall::MarshalObjectToVariant( value );
//
// We will have a SAFEARRAY of BSTRs in the VARIANT...
//
VariantClear( &var );
}
// and the reverse, in C++/CX
Object ^ GetValue()
{
VARIANT var;
VariantInit(&var);
v.vt = VT_BSTR | VT_ARRAY;
SAFEARRAYBOUND sab;
sab.cElements = 2;
sab.lLbound = 0;
SAFEARRAY *psa = SafeArrayCreate( VT_BSTR, 1, &sab );
LPVOID p = NULL;
SafeArrayAccessData( psa, &p );
((BSTR *) p)[0] = SysAllocString(L"string one");
((BSTR *) p)[1] = SysAllocString(L"string two");
SafeArrayUnaccessData( psa );
var.parray = psa;
Object ^ obj = acMarshall::MarshalVariantToObject( var );
VariantClear( &var );
return obj;
}
//and in C#:
object obj = GetValue() //obj will contain a string array...
Regards,
Roger

Answer 2

There is no "VARIANT" equivalent in the Windows Runtime. At the ABI level, System::Object is represented as an object implementing IInspectable, that may be a mechanism that you can use to replace your variant.
It is possible to use IReference to create an IInspectable based interface which represents your higher level objects but it won't have the weakly typed semantics that VARIANT does.