As Brian already pointed out, such method cannot be called by VB.
You can cease and desist at this point. Implement two interfaces -
one Automation-compatible for use by VB, and the other with rich
types for use by C/C++ clients (derived from IUnknown of course).
BTW, unfortunately your troubles don't stop at this point since your
rich types method is not marshalable. You'll need to use two methods
in a local/call_as pair in order to marshal the second argument when
it carries a NULL pointer:
[local]
HRESULT get_List(SHORT* pListSize, SHORT* pList);
[call_as(get_List)]
HRESULT rem_get_List([in, out] SHORT* pListSize, [in, out,
size_is(*pListSize)] SHORT* pList);
Then you need to write two shim functions in C to link with the proxy/stub
code. In the client-side shim you only call the real interface methods
if the second argument is not NULL. If it is NULL, you can use for
example a local array of size 1 and then pass 1 for the size in the first
argument. You only report the size to your caller. The server-side
shim is straightforward - you simply call the object's method with the
passed-in arguments. You can find the signatures generated for you
(in extern form of course) by the MIDL compiler in the resultant _p.c
file.
While on the subject, let me recommend you to use conformant
arrays instead:
HRESULT get_List([out] SHORT* pListSize, [out, size_is(,*pListSize)] SHORT**
pList);
You allocate the array at the callee via CoTaskMemAlloc and free it at
the caller via CoTaskMemFree.
--
=====================================
Alexander Nickolov
Microsoft MVP [VC], MCSD
email: agnickolov@mvps.org
MVP VC FAQ: http://vcfaq.mvps.org
=====================================
"John" <John@discussions.microsoft.com> wrote in message
news:28D7598A-416A-4B7A-AD18-C9448D953797@microsoft.com...
Brian,
The whole reason behind what I am doing is to get away from using a
safearray
and it's overhead. The server is mainly going to be used by C/C++ clients
but it
does need to support VB.
What I am trying to accomplish can be explained better in this sample
piece
of
code;
// On the Server side
HRESULT CSomeObj::get_List(short* plistitems, short* plist)
{
if (!plistitems) return E_POINTER;
*plistitems = 10;
if (plist) {
short i;
for (i=0; i<10; i++)
list[i] = i;
}
return S_OK;
}
// C/C++ client side
short nlist, *plist = NULL;
ComPtr<ISomeObj> pobj;
pobj.CoCreateInstance(CLSID_SomeObj);
pobj->get_List(&nlist, NULL); // query list
elements
plist = new short[nlist]; // allocate list
pobj->get_List(&nlist, plist); // get list
delete [] plist;
// now on the VB side I would like to perform the same
Dim obj as New someLib.SomeObj
Dim nlist as integer
Dim nlistitems () as integer
obj->list nlist, NULL // NULL for example purposes only
Redim listitems (0 to nlist)
obj->list nlist, listitems(0)
The problem is there seems to be no corresponding NULL pointer for VB.
I've tried just about everything but it always passes in a pointer
(probably to a Variant) not 0, i.e. NULL.
Like I said in my previous post it works when calling a Win32 DLL. For
instance
the ReadFile function from kernel32.dll can be declared in VB;
Private Declare Function ReadFile Lib "kernel32" ( _
ByVal hFile As Long, _
lpBuffer As Any, _
ByVal nNumberOfBytesToRead As Long, _
lpNumberOfBytesRead As Long, _
lpOverlapped As Any) As Long
and called using the following, which passes NULL for lpOverlapped
ReadFile(hCom(0), ByVal b, 32, bytesread, ByVal 0)
The declare statement allows you to specify 'As Any' in the function
declaration and
'ByVal 0' in the actual function call. It appears this may not be
possible
if you are
using an object from a DLL ( I'm baffled).
Any other suggestions would be greatly appreciated.
"Brian Muth" wrote:
"John" <John@discussions.microsoft.com> wrote in message
news:B61E421F-7F25-47DD-A73E-31D00E529D56@microsoft.com...
I have a object that returns a list of items from one of it's methods. I
implemented this method using a two step process:
short nitems, *plistitems;
obj->get_List(&nitems, NULL); // get items in list, NULL = no
output array
plistitems = new short[nitems]; // allocate array
obj->get_List(&nitems, plistitems); // call again get items in list
and
the items
delete [] plistitems; // free array
the idl file has the following syntax:
HRESULT get_List([in, out] SHORT* pListSize, [in, out] SHORT* pList);
This won't work. If it is working for you, it is purely by accident
presumably because the client and the ATL object is in the same apartment
and there is no marshaling involved. by default, only the first element
of
the array is being marshaled. Normally you would use the size_is
attribute
to indicate the number of elements to marshal.
Unfortunately, even if you make this change, it really won't help you if
the
client is VB code. The reason is, a VB array is quite different from an
C++
array, and the C++ array cannot readily be manipulated by VB.
Instead, you should define the ATL methods in a VB6 friendly way. You can
do
this using SAFEARRAY's instead, as in:
HRESULT get_List ([in, out] SAFEARRAY(SHORT)* pList)
You will find that the implementation signature is:
HRESULT get_List ([in, out] SAFEARRAY** pList)
The size of the array is contained within the SAFEARRAY structure, so you
don't need to have a second parameter indicating the number of elements
in
the array.
This will work very nicely with a VB6 client, that might code:
Dim x as New MyList
Dim r(10) as Integer
x.List r
HTH
Brian