have sample implementation as well. I did a search and this is
http://groups.google.com/group/microsoft.public.vc.atl/browse_thread/thread/9db0c444b156b395
Note that Peter's code is not plain C. For C you need to define
COBJINTERFACES and use the C macro for calling into the interface.
Alexander,
Thanks for the plathora of information!
I do believe that I found the sample code that you were talking about it
was
from 1999
http://groups.google.com/group/microsoft.public.vc.activex.templatelib/browse_thread/thread/8ccd2a4e4573d753/4e6624998f7246f4?#4e6624998f7246f4
Although when you look at the post it seems that Peter Partch documented
the
local and call_as shims backwards doesn't it?
Just for kicks I tried writing the shims (in dlldatax.c) for my example
object and it doesn't compile, it tells me that get_List is not a member
of
IPXTest, (intillesense sees it) do you have to include an additional file?
//////////////////
// idl file
//////////////////
interface IPXTest : IUnknown {
[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);
};
/////////////////
// in dlldatax.c
////////////////
HRESULT STDMETHODCALLTYPE IPXTest_get_List_Proxy (
IPXTest __RPC_FAR * This,
/* [in, out] */ SHORT __RPC_FAR *pCount,
/* [in, out] */ SHORT __RPC_FAR *pList)
{
HRESULT hr = IPXTest_rem_get_List_Proxy(This, pCount, pList);
return hr;
}
HRESULT STDMETHODCALLTYPE IPXTest_get_List_Stub (
IPXTest __RPC_FAR * This,
/* [in, out] */ SHORT __RPC_FAR *pCount,
/* [in, out] */ SHORT __RPC_FAR *pList)
{
HRESULT hr = This->get_List(pCount, pList);
return S_OK;
}
I know the code isn't following my plan of having a NULL as the second
argument, but I wanted to test the writing and linking of the shims.
"Alexander Nickolov" wrote:
See inline.
--
=====================================
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:7D08FD9F-A32F-466B-A804-89B34672711D@microsoft.com...
Thanks Alexander,
This brings up some additional questions
- Is all this necessary if the client and server are in the same
apartment?
local/call_as is necessary fior marshaling. There's no marshaling if both
the caller and the object reside in the same apartment. You still should
mark your interface [local] though - to ensure no marshaling code is
generated so clients get an early and definitive error instead of being
left scratching their head at the unexpected error when the offending
method is called.
- We have ported a win32 dll to a COM object and can perform the
following
from VB without error, or is this an error waiting to happen?
Dim array (0 to 9) as Double
Dim s as Double
Dim i as Integer
for i = 0 to 9
array(i) = i
someObj.Sum s, 10, array(0)
This doesn't involve arrays - you are passing scalars. If you assume
there's more than one element in the third argument - you are up for a
surprise when marshaling occurs. You can only pass a safe array through
a COM interface method from VB6. And note your current code does
not use a safe array in VB6 - in order to make it a safe array it has to
be
declared as:
Dim array() as Double
Redim array(0 to 9)
- Is it common practice to define two interfaces one for C/C++ and
another
for
automation compatible clients?
Only when it makes sense. Sometimes you may find it makes no sense to
provide VB6-compatible interface at all due to the low-level nature of
the
object. In that case you expose a different object built on top of the
original
object that exposes simplified interface. You can even bundle together
the
functionality of several objects in this way. Case in point: OLE DB and
ADO.
- When is the local/call_as truly needed (Service/DCOM)?
No - it's needed for marshaling. Marshaling doesn't need to involve
neither services nor DCOM. A regular local COM server (EXE) or
in-proc server (DLL) with incompatible threading model also involves
interface marshaling.
- Could this all be avoided if I had a property that got the list size
and
another
property that got the list?
You could do it that way, but it's simpler if you get them both together.
Safe arrays and conformant arrays do exactly that.
- And finally do you know of any example code that shows how to use
local, call_as?
I've posted such code at least once in the past in this same newsgroup.
You can search for call_as and my name on google groups. It'd likely be
a couple years old post. Again, I recommend against using that approach
in favor of conformant arrays.
Thanks
"Alexander Nickolov" wrote:
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