\n\nLast time<\/A>,\nwe learned about how connection points work.\nOne special case of this is where the connection interface\nis a dispatch interface.\n<\/P>\n \nDispatch interfaces are, as the name suggests,\nCOM interfaces based on \nI’m assuming you know how \nNowadays, this sort of thing goes by the fancy name of reflection<\/I>,\nbut back in the OLE Automation days,\nit was simply all in a day’s work.\nYou kids think you invented everything<\/I>.\n<\/P>\n \nJust like as with regular connection point interfaces,\na dispatch interface used as a connection point interface\nconsists of events which are formally implemented as methods.\n<\/P>\n \nYou declare that your object is a source of events for this interface\nby noting it in your object declaration.\n(Thanks, Medinoc for\n\nnoting the error in the original version of this article<\/A>.)\n<\/P>\n \nA client registers with the connection point with the\n \nNow, formally, when the connection point wants to invoke\nthe \nIn other words, the connection point already knows that\nthe ID for the method \nThis means that in practice, the only method on the\nclient that is ever called is\n \nHere is a template base class that I use for my connection point interface\nimplementations of dispatch interfaces.\nWe’ll discuss the pieces afterwards:\n<\/P>\n \/* IUnknown *\/\n IFACEMETHODIMP QueryInterface(REFIID riid, void **ppv)\n {\n *ppv = nullptr;\n HRESULT hr = E_NOINTERFACE;\n if (riid == IID_IUnknown || riid == IID_IDispatch ||\n riid == __uuidof(DispInterface))\n {\n *ppv = static_cast<DispInterface *>\n (static_cast<IDispatch*>(this));\n AddRef();\n hr = S_OK;\n }\n return hr;\n }<\/p>\n IFACEMETHODIMP_(ULONG) AddRef()\n {\n return InterlockedIncrement(&m_cRef);\n }<\/p>\n IFACEMETHODIMP_(ULONG) Release()\n {\n LONG cRef = InterlockedDecrement(&m_cRef);\n if (cRef == 0) delete this;\n return cRef;\n }<\/p>\n \/\/ *** IDispatch ***\n IFACEMETHODIMP GetTypeInfoCount(UINT *pctinfo)\n {\n *pctinfo = 0;\n return E_NOTIMPL;\n }<\/p>\n IFACEMETHODIMP GetTypeInfo(UINT iTInfo, LCID lcid,\n ITypeInfo **ppTInfo)\n {\n *ppTInfo = nullptr;\n return E_NOTIMPL;\n }<\/p>\n IFACEMETHODIMP GetIDsOfNames(REFIID, LPOLESTR *rgszNames,\n UINT cNames, LCID lcid,\n DISPID *rgDispId)\n {\n return E_NOTIMPL;\n }<\/p>\n IFACEMETHODIMP Invoke(\n DISPID dispid, REFIID riid, LCID lcid, WORD wFlags,\n DISPPARAMS *pdispparams, VARIANT *pvarResult,\n EXCEPINFO *pexcepinfo, UINT *puArgErr)\n {\n if (pvarResult) VariantInit(pvarResult);\n return SimpleInvoke(dispid, pdispparams, pvarResult);\n }<\/p>\n \/\/ Derived class must implement SimpleInvoke\n virtual HRESULT SimpleInvoke(DISPID dispid,\n DISPPARAMS *pdispparams, VARIANT *pvarResult) = 0;<\/p>\n public:\n HRESULT Connect(IUnknown *punk)\n {\n HRESULT hr = S_OK;\n CComPtr<IConnectionPointContainer> spcpc;\n if (SUCCEEDED(hr)) {\n hr = punk->QueryInterface(IID_PPV_ARGS(&spcpc));\n }\n if (SUCCEEDED(hr)) {\n hr = spcpc->FindConnectionPoint(__uuidof(DispInterface), &m_spcp);\n }\n if (SUCCEEDED(hr)) {\n hr = m_spcp->Advise(this, &m_dwCookie);\n }\n return hr;\n }<\/p>\n void Disconnect()\n {\n if (m_dwCookie) {\n m_spcp->Unadvise(m_dwCookie);\n m_spcp.Release();\n m_dwCookie = 0;\n }\n }<\/p>\n private:\n LONG m_cRef;\n CComPtr<IConnectionPoint> m_spcp;\n DWORD m_dwCookie;\n};\n<\/PRE>\n \nFirst, a distraction: Our \nThe bulk of the class merely stubs out all the methods\nof \nFinally, there are two public methods\n \nExercise<\/B>:\nIs the \nThis helper template class makes writing dispatch interface\nconnection point clients really simple,\nsince all you have to do is implement HRESULT SimpleInvoke(\n DISPID dispid, DISPPARAMS *pdispparams, VARIANT *pvarResult)\n{\n switch (dispid) {\n case WDISPID_RENAMED:\n HeyLookItGotRenamed(pdispparams->rgvarg[0].bstrVal,\n pdispparams->rgvarg[1].bstrVal);\n break;\n }\n return S_OK;\n};\n<\/PRE>\n \nIn the IDispatch<\/CODE>.\nThe IDispatch<\/CODE> interface is the base interface\nfor OLE automation objects,\nand if you want your connection point interface to be usable\nfrom script,\nyou probably should make it a dispatch interface.\n<\/P>\nIDispatch<\/CODE> works.\nThe short version is that script that wants to invoke\na method or property calls\nGetIDsOfNames<\/CODE> to get the\ndispatch ID<\/I> for the method or property it wants\nto access,\nand it uses the type library to figure out\nthings like the parameters and return value.\nOnce the scripting engine figures out how the method or property\nexpects to be called,\nit can call\nIDispatch::Invoke<\/CODE>\npassing the dispatch ID and a DISPPARAMS<\/CODE> structure\nthat holds the parameters.\n<\/P>\n\ndispinterface DWidgetEvents\n{\n [id(WDISPID_RENAMED)]\n HRESULT Renamed([in] BSTR oldName, [in] BSTR newName);\n…\n};\n<\/PRE>\n\ncoclass Widget\n{\n [default] interface IWidget;\n [default, source] dispinterface DWidgetEvents;<\/FONT>\n}\n<\/PRE>\nDIID_DWidgetEvents<\/CODE> interface.\nBy convention, dispatch interfaces usually end\nwith the word Events<\/CODE>\nand are often prefixed with the letter D<\/CODE>,\nand the interface ID symbol begins with DIID<\/CODE>\nrather than simply IID<\/CODE>.\nThese conventions are not universally adhered-to,\nso don’t freak out if you see people who don’t follow them.\n(If you declare your dispatch interface in an IDL file,\nthen the MIDL compiler will\ngenerate the dispatch interface ID with\nthe DIID<\/CODE> prefix for you.)\n<\/P>\nRenamed<\/CODE> method, it calls\nGetIDsOfNames<\/CODE> to get the ID\nfor the method called L”Renamed”<\/CODE>, and asks\nfor the type library to figure out what the parameters are.\nBut this is frequently just pointless busy-work:\nThe connection point often already knows the answer,\nsince the connection point already knows what interface\nit is talking to.\nIt doesn’t need to do any “reflection” since the connection\npoint already knows what the IDs and calling conventions are.\nIn the same way, your C# code doesn’t need to use reflection\nto call a method on an object whose assembly you already have\nreferenced in your project.\n(The GetIDsOfNames<\/CODE> exists not for\nconnection points, but rather to assist\ndynamically-typed languages, where you can try to invoke any method\non any object, and the method is looked up at run time.)\n<\/P>\nRename<\/CODE> is\nWDISPID_RENAMED<\/CODE>, and that it takes two\nBSTR<\/CODE> parameters,\nbecause that was part of the contract for registering with\nthe connection point in the first place.\n<\/P>\nIDispatch::Invoke<\/CODE>.\n<\/P>\n\ntemplate<typename DispInterface>\nclass CDispInterfaceBase : public DispInterface\n{\npublic:\n CDispInterfaceBase() : m_cRef(1), m_dwCookie(0) { }<\/p>\nQueryInterface<\/CODE>\nimplementation performs a double-cast of this<\/CODE>\nto IDispatch<\/CODE>, then to the templated interface.\nThis ensures that the templated interface pointer\nand IDispatch<\/CODE> are compatible.\nIt would be bad if somebody tried to use this\nQueryInterface<\/CODE> implementation\nwith something unrelated to IDispatch<\/CODE>.\n(Yes, I could’ve used std::is_base_of<\/CODE>,\nbut I’m an old-timer who grew up before TR1.)\n<\/P>\nIDispatch<\/CODE>,\nsave for\nIDispatch::Invoke<\/CODE>, which does a little\ngrunt work (initializing the result VARIANT<\/CODE>)\nand then leaves the derived class to do the heavy lifting.\n<\/P>\nConnect<\/CODE> and Disconnect<\/CODE>.\nThese perform the Advise<\/CODE> and\nUnadvise<\/CODE> calls we saw yesterday.\nTo simplify things for our caller,\nwe save the IConnectionPointer<\/CODE>\nwe registered against so that the caller doesn’t\nhave to pass it back in when disconnecting.\n<\/P>\nm_spcp.Release()<\/CODE> call\nin Disconnect<\/CODE>\nreally necessary?\n(Assuming that Connect<\/CODE> is called at most once.)\n<\/P>\nSimpleInvoke<\/CODE>\nin the form of a switch<\/CODE> statement on the\ndispatch IDs you care about:\n<\/P>\n\nclass CWidgetClient : public CDispInterfaceBase\n{\npublic:\n CWidgetClient() { }<\/p>\nSimpleInvoke<\/CODE> method,\nwe switch on the dispatch ID,\nand if we see one we like, we extract the parameters from the\npdispparams<\/CODE>.\n<\/P>\n