Collections Interoperability

• Download source - 0.8 Kb
• Download demo - 30.6 Kb

Introduction

In my work, I am using a COM object as an interface between a managed server and a HW device that has a C DLL interface. Last week, I encountered the need to pass a collection from the HW device to the server. To do that, I had the COM read it from the device and pass it to the server. The problem was that I couldn’t return a collection of my UDT (User Defined Type) from COM to the managed server.

The code

So how do we return a UDT from native to managed code?

The easiest way to achieve interoperability between native and managed code is by putting the unmanaged code in a COM object. So what is left is to return the collection from COM to the managed code.

COM has two ways to return collections:

1. Return a C style array like so:

   HRESULT Foo(int Length, [length_is(Length)]  SUDTStruct  Col[]);

2. Return a SAFEARRAY with the collection like so:

   If you use IDL, the syntax is:

   HRESULT Foo(SAFEARRAY(SUDTStruct) **Col)

   If you use embedded IDL, the syntax is:

   HRESULT Bar([out, satype(struct PTZPresetsInfo))] SAFEARRAY **Col)

The first way does not work with .NET. The interop proxy that will be created for it will look like:

void Foo(int Length, ref  SUDTStruct  Col)

which means that only one struct will be returned and not the whole collection, so the only way is using a safe array.

To do that we need a few simple stages:

1. Define the UDT you want to pass in the collection.
2. Define a GUID for the UDT:

   [export,
   uuid("3DA0FCDB-BAC1-4b13-8808-AB3E43A281BA")]
   struct SUDTStruct
   {
           ...
   };
   

3. Define a get function:

   HRESULT Bar(([out, satype(struct PTZPresetsInfo)) SAFEARRAY **Col)
   

4. Implement the get function by creating a SAFEARRAY and returning it:

   SAFEARRAY *pSafeArrayCol;
   unsigned int ndim =  1;
   
   USES_CONVERSION;
   SAFEARRAYBOUND  rgbounds;
   rgbounds.lLbound = 0;
   rgbounds.cElements = ColSize;
   
   IRecordInfo*                  pRecInfo = NULL;
   
   ITypeLib* pTypelib = NULL;
   HRESULT hr = LoadTypeLib(A2OLE("UDT TYPE LIBRARY"),&pTypelib);
   if (FAILED(hr))
   {
           return NULL;
   }
   
   ITypeInfo *pTypeInfo;
   hr =
     pTypelib->GetTypeInfoOfGuid(__uuidof(CollectionType::value_type),
                                                          &pTypeInfo);
   if (FAILED(hr))
   {
           return NULL;
   }
   
   hr = GetRecordInfoFromTypeInfo(pTypeInfo, &pRecInfo);
   if (FAILED(hr))
   {
           return NULL;
   }
   
   pSafeArrayCol = SafeArrayCreateEx(VT_RECORD, 1,
                                     &rgbounds, pRecInfo);
   pRecInfo->Release();
   
   CollectionType::value_type *pItem;
   hr = SafeArrayAccessData(pSafeArrayCol,
           reinterpret_cast<PVOID*>(&pItem));
   

5. Init the collection pointed to by pItem:

   SafeArrayUnaccessData(pSafeArrayCol);
   

A few remarks: if you want to pass a collection of a UDT to COM all you need to do is define a UDT with a GUID and define a function like so:

HRESULT Bar(SAFEARRAY([in] SUDTStruct) *Col)

This function will appear in the .NET interop like so:

void Bar(System.Array Col)

When calling it, pass a SUDTStruct[] as the collection:

In order to ease the process of creating the safe array I created a simple template function that receives a STL collection that has the UDT as its value type and create a safe array out of it with the same data. The source is attached to this article.

For example:

std::vector<SUDTStruct> Col;
 
// init the collection with the data
SAFEARRAY *pSafeArrayCol = CreateUDTSafeArrayFromCol(Col);

The CreateSafeArray function will create a safe array and initialize it with the data in the STL collection.

The demo project attached is a COM object and a .NET assembly that sends and gets collections from it.

Points of Interest

Microsoft has done a lot of work to make COM a mechanism for interoperability between managed and unmanaged areas, but not all the COM capability is exported through the .NET proxy created for COM.