Chris Sells
Marquee de Sells: Chris's insight outlet
July 19, 2001 tools

SmartEnumVARIANT

The Problem

VB/VBScript provides the implementation of For-Each using an implementation of IEnumVARIANT exposed from a collection via the _NewEnum method. Unfortunately, VB uses 1 for the argument to Next, making round-trip time terrible.

A Solution:
If you don’t own the collection implementation code…

If you don’t own the collection implementation code, you can still wrap the collection in a custom object called the CollectionBuffer, which implements the following interface: 
[
	object,
	uuid(B6175081-83D4-11D2-987D-00600823CFFB),
	dual,
	helpstring("ICollectionBuffer Interface"),
	pointer_default(unique)
]
interface ICollectionBuffer : IDispatch
{
    [propget, helpstring("property Collection")] HRESULT Collection([out, retval] IDispatch** pVal);
    [propput, helpstring("property Collection")] HRESULT Collection([in] IDispatch* newVal);
    [propget, helpstring("property BufferSize")] HRESULT BufferSize([out, retval] long *pVal);
    [propput, helpstring("property BufferSize")] HRESULT BufferSize([in] long newVal);
    [propget, id(DISPID_NEWENUM)] HRESULT _NewEnum([out, retval] IUnknown** ppunkEnum);
};
The Collection property is used to pass in the collection object to which you’d like buffered access. The BufferSize property is used to control how many VARIANTs you’d like to have returned on each call to Next. The implementation of _NewEnum gets the IEnumVARIANT interface from the collection and wraps it in a buffered implementation of IEnumVARIANT called SmartEnumVARIANT.

The SmartEnumVARIANT object manages buffered access to the underlying IEnumVARIANT. VB can still ask for one item at a time, but the items will come out of the buffer. Depending on the buffer size, this can improve performance by many order of magnitude.

Usage

The following VB code uses an unbuffered collection and is slow: 
Dim coll As Object
Set coll = CreateObject("DumbEnumSvr.CollectionOfNumbers")
coll.CountOfNumbers = 10000

Dim v As Variant
Dim c As Long
For Each v In coll
    c = c + 1
Next v
MsgBox "Counted " & c
This VB code wraps the unbuffered collection in the CollectionBuffer object: 
Dim collBuffer As Object
Set collBuffer = CreateObject("SmartEnumSvr.CollectionBuffer")
collBuffer.Collection = coll
collBuffer.BufferSize = 1024

c = 0
For Each v In collBuffer
    c = c + 1
Next v
MsgBox "Counted " & c

Another Solution:
If you do own the collection implementation code…

If you do have the source to the collection, there’s no reason that VB clients have to do anything. Instead, your implementation of IEnumVARIANT can use a manual form of handler marshaling (invented, as far as I know, by Don Box —  the manual form, MS invented handler marshaling…).

The handler marshaling works like this:

  1. The server-side implementation of IEnumVARIANT implements IMarshal.
  2. Server-side enumerator returns CLSID_SmartEnumVARIANT when GetUnmarshalClass is called.
  3. Server-side enumerator marshals the interface of it’s own stub (obtained by calling CoGetStandardMarshal) into the stream provided during the call to GetMarshalSizeMax and MarshalInterface.
  4. On the client-side, the Proxy Manager used the CLSID provided by the server-side enumerator to create an instance of SmartEnumVARIANT.
  5. The SmartEnumVARIANT object also implements IMarshal and it will pull the marshaled stub to the real implementation of IEnumVARIANT out of the marshal packet.
  6. The SmartEnumVARIANT becomes a “smart proxy,” forwarding calls to the server-side implementation of IEnumVARIANT. However, instead of forwarding _Next calls directly, the calls are buffered for efficiency.
This solution is nice because the VB client doesn’t have to do anything special. When the server-side implementation of IEnumVARIANT is marshaled to the client, the SmartEnumVARIANT automatically becomes the smart proxy, making buffered calls on the server.

For the handler marshaling to work, the server-side enumerator must implement IMarshal appropriately. In UseSmartEnum.h, I’ve provided an implementation of IMarshal for this purpose: 

template <typename Deriving, ULONG celtBuffer = 1024>
class IMarshalForSmartEnumImpl : public IMarshal {...};
For example, the CollectionOfNumbers2 example class uses IMarshalForSmartEnumImpl to add IMarshal to CComEnum like so: 
typedef CComEnum< IEnumVARIANT, &IID_IEnumVARIANT, VARIANT, _Copy<VARIANT> > CComEnumVariant;

class CSmartProxiedEnumVARIANT :
    public CComEnumVariant,
    public IMarshalForSmartEnumImpl<CSmartProxiedEnumVARIANT, 1024>
{
public:
BEGIN_COM_MAP(CSmartProxiedEnumVARIANT)
    COM_INTERFACE_ENTRY(IMarshal)
    COM_INTERFACE_ENTRY_CHAIN(CComEnumVariant)
END_COM_MAP()
};

The Source

CollectionBuffer, SmartEnumVARIANT, IMarshalForSmartEnumVARIANT and two samples, CollectionOfNumbers (which doesn’t use handler marshaling) and CollectionOfNumbers2 (which does use handler marshaling) are available here.

Copyright

This source is copyright (c) 1998, Chris Sells.
All rights reserved. No warrenties extended. Use at your own risk.
Comments to csells@sellsbrothers.com