Re: IDispatch and dispinterface
George <George@discussions.microsoft.com> wrote:
[uuid(BFB73347-822A-1068-8849-00DD011087E8), version(1.0),
helpstring("Useful help string."), helpcontext(2480)]
dispinterface IMyDispatch {
properties:
[id(1)] int x; // An integer property named x.
[id(2)] BSTR y; // A string property named y.
methods:
[id(3)] void show(); // No arguments, no result.
[id(11)] int computeit(int inarg, double *outarg);
};
1. expose the interface IMyDispatch, and not expose IDispatch;
You'd typically expose both. It would actually be the same interface -
IDispatch - made available by two different IIDs. Like this:
class MyClass : public IDispatch, ... {
BEGIN_COM_MAP(MyClass)
COM_INTERFACE_ENTRY(IDispatch)
COM_INTERFACE_ENTRY_IID(IID_IMyDispatch, IDispatch)
END_COM_MAP()
};
2. and interface IMyDispatch will expose the 4 methods in IDispatch
with the same methods' name/signature, in additional to the
methods/properties defined below -- like x, y and show;
The terminology may be confusing, as the term "method" here has two
different meanings. A regular COM interface method is a slot in that
interface's vtable. A dispinterface method is a DISPID plus an agreement
of which parameters should be passed along with that DISPID. A
dispinterface has 7 (seven) COM methods in its vtable (the same ones
IDispatch has). It can support an arbitrary number of dispinterface
methods (and properties: a property is really just a pair of methods - a
getter and a setter - sharing the same DISPID).
This line in the IDL
[id(3)] void show();
simply means that
a) When your implementation of IDispatch::GetIdsOfNames is called with
"show" as a parameter, it will produce a DISPID of 3.
b) Your implementation of IDispatch::Invoke can be called passing a
DISPID of 3 and no parameters in DISPPARAMS (and will presumably do
something reasonable and useful when thus called; at least, it won't
fail with DISP_E_MEMBERNOTFOUND error).
3. interface IMyDispatch will derive from IUnknown and have a
different IID from IDispatch;
Well, all interfaces derive from IUnknown and have distinct IIDs. So
yes, this is trivially true.
4. the methods and properties of dispinterface IMyDispatch will not be
invoked by vtable of IMyDispatch, but invoked by Invoke method, even
if the methods like x, y and show are exposed.
I'm not sure what you mean by "exposed" here. Other than that part, yes,
this is correct.
But what is the inheritance relationship between IDispatch and
dispinterface IMyDispatch?
Usually, IMyDispatch simply doesn't exist as a class in your C++
program. You write IDispatch instead.
No inheritance relationship -- means
dispinterface IMyDispatch is not derived from IDispatch, they are
just totally two different interfaces without any inheritance
relationship, just expose the same 4 methods --
GetTypeInfoCount/GetTypeInfo/GetIDsOfNames/Invoke?
You could, in principle, do it this way, but I don't quite see why you
would want to. You could also derive IMyDispatch from IDispatch and
leave it otherwise empty - though again, I don't see the point. Simply
use IDispatch everywhere, it already specifies the correct vtable
layout, which is all you need on C++ side of things.
What I am not sure is whether in the vtable of IMyDispatch, x, y,
show and computeit should be included?
Din't you just say, in your item #4, that they shouldn't?
--
With best wishes,
Igor Tandetnik
With sufficient thrust, pigs fly just fine. However, this is not
necessarily a good idea. It is hard to be sure where they are going to
land, and it could be dangerous sitting under them as they fly
overhead. -- RFC 1925