引言

前面九月份的八篇关于COM的文章，说的都是进程内COM。那时，我们从一个含内嵌IE控件的窗口说起，根据COM协议手工书写了进程内COM组件，并由此积累了一些类似ATL的框架性代码。

今天开始，我们把脚步迈向进程外组件。同样是从最基础的开始，本篇我们将根据进程外COM组件的加载规范手工编写一个EXE，然后用标准的COM调用方法来使用它。之前积累的框架性代码不属于第三方库，所以这里不会避免去使用，相反地，会把一些通用性较强的代码直接扩充到框架中。

本文仅限于常规EXE。NT服务程序暂时不在讨论之列。

命令行规范

进程外COM不像DLL，不需要实现四个导出函数。取而代之地，需要实现一些命令行参数：

1. /RegServer

2. /UnregServer

3. /RegServerPerUser

4. /UnRegServerPerUser

我没有找到官方文档，只是从ATL的实现来找到了上述四个参数。从名字来看，很容易理解。前两个相当于进程内组件的 DllRegisterServer 和 DllUnregisterServer，后两个针对当前用户，相当于 DllInstall(“user”)。

从ATL的实现代码来看，命令的前导符号不必是“/”，也可以是“-”。

另外，从测试情况来看，当COM库加载进程外组件的时候，会带上参数“-Embedding”，这可以用于区分用户主动运行还是被COM库加载。

注册和反注册

为了快速达到运行目的，今天我们只实现/RegServer和/UnregServer，后两个先不管了。

进程外COM和进程内COM的注册表结构大体一致，“粗看”发现，唯一的区别是，CLSID下的InprocServer32变成了LocalServer32。另外一个关键点是，我们自定义的每一个接口都需要注册到Interface下。Interface键结构：

第二个，TypeLib，跟CLSID的TypeLib一样。

第一个，ProxyStubClsid32，是要注册该接口的代理存根对象，用于序列化/反序列化参数和返回值。序列化/反序列化在COM中的术语是列集/散集，超不喜欢这名字。我们这里不实现自定义的代理存根，直接写死“{00020424-0000-0000-C000-000000000046}”，用系统的。不过使用这个代理存根有个局限，接口必须符合下列两种情况之一：

1. 实现了IDispatch接口，并在IDL中把接口属性标记为dual。

2. 只使用VARIANT兼容的数据类型，并在IDL中把接口属性标记为oleautomation。

另外说一点，ATL的 /RegServer，仅仅注册 dual 的接口。这点我们这里不学。

下面修改以前的ComModule::RegisterTypeLib，增加注册Interface的代码：

bool RegisterTypeLib(HKEY hRootKey)

{

String strPath;

strPath += _T("Software\\Classes\\TypeLib\\");

strPath += m_strLibID;

strPath += _T("\\");

strPath += m_strLibVersion;

if (!Registry::SetString(hRootKey, strPath, _T(""), m_strLibName))

{

return false;

}

strPath += _T("\\0\\");

#ifdef _WIN64

strPath += _T("Win64");

#else

strPath += _T("Win32");

#endif

if (!Registry::SetString(hRootKey, strPath, _T(""), m_strModulePath))

{

return false;

}

for (UINT i = 0; i < m_pTypeLib->GetTypeInfoCount(); ++i)

{

TYPEKIND type = TKIND_MAX;

HRESULT hr = m_pTypeLib->GetTypeInfoType(i, &type);

if (FAILED(hr))

{

return false;

}

if (type != TKIND_INTERFACE && type != TKIND_DISPATCH)

{

continue;

}

ITypeInfo *pTypeInfo = nullptr;

hr = m_pTypeLib->GetTypeInfo(i, &pTypeInfo);

if (FAILED(hr))

{

return false;

}

XL_ON_BLOCK_EXIT(pTypeInfo, &ITypeInfo::Release);

TYPEATTR *pAttr = nullptr;

pTypeInfo->GetTypeAttr(&pAttr);

if (FAILED(hr))

{

return false;

}

XL_ON_BLOCK_EXIT(pTypeInfo, &ITypeInfo::ReleaseTypeAttr, pAttr);

TCHAR szInterfaceID[40] = {};

StringFromGUID2(pAttr->guid, szInterfaceID, ARRAYSIZE(szInterfaceID));

String strInterfacePath;

strInterfacePath += _T("Software\\Classes\\Interface\\");

strInterfacePath += szInterfaceID;

if (!Registry::SetString(hRootKey, strInterfacePath + _T("\\ProxyStubClsid32"), _T(""), _T("{00020424-0000-0000-C000-000000000046}")))

{

return false;

}

if (!Registry::SetString(hRootKey, strInterfacePath + _T("\\TypeLib"), _T(""), m_strLibID.GetAddress()))

{

return false;

}

if (!Registry::SetString(hRootKey, strInterfacePath + _T("\\TypeLib"), _T("Version"), m_strLibVersion.GetAddress()))

{

return false;

}

return true;

}

反注册相应地增加删除Interface的代码：

bool UnregisterTypeLib(HKEY hRootKey)

{

for (UINT i = 0; i < m_pTypeLib->GetTypeInfoCount(); ++i)

{

TYPEKIND type = TKIND_MAX;

HRESULT hr = m_pTypeLib->GetTypeInfoType(i, &type);

if (FAILED(hr))

{

return false;

}

if (type != TKIND_INTERFACE && type != TKIND_DISPATCH)

{

continue;

}

ITypeInfo *pTypeInfo = nullptr;

hr = m_pTypeLib->GetTypeInfo(i, &pTypeInfo);

if (FAILED(hr))

{

return false;

}

XL_ON_BLOCK_EXIT(pTypeInfo, &ITypeInfo::Release);

TYPEATTR *pAttr = nullptr;

pTypeInfo->GetTypeAttr(&pAttr);

if (FAILED(hr))

{

return false;

}

XL_ON_BLOCK_EXIT(pTypeInfo, &ITypeInfo::ReleaseTypeAttr, pAttr);

TCHAR szInterfaceID[40] = {};

StringFromGUID2(pAttr->guid, szInterfaceID, ARRAYSIZE(szInterfaceID));

String strInterfacePath;

strInterfacePath += _T("Software\\Classes\\Interface\\");

strInterfacePath += szInterfaceID;

if (!Registry::DeleteKeyRecursion(hRootKey, strInterfacePath))

{

return false;

}

String strPath;

strPath += _T("Software\\Classes\\TypeLib\\");

strPath += m_strLibID;

if (!Registry::DeleteKeyRecursion(hRootKey, strPath))

{

return false;

}

return true;

}

再给RegisterComClasses新增个参数：

bool RegisterComClasses(HKEY hRootKey, bool bInprocServer = true)

相应注册逻辑修改如下：

if (bInprocServer)

{

if (!Registry::SetString(hRootKey, strClassIDPath + _T("\\InprocServer32"), _T(""), m_strModulePath))

{

return false;

}

else

{

if (!Registry::SetString(hRootKey, strClassIDPath + _T("\\LocalServer32"), _T(""), m_strModulePath))

{

return false;

}

然后，汇总一下，写两个供调用的接口函数：

STDMETHODIMP ExeRegisterServer()

{

if (!RegisterTypeLib(HKEY_LOCAL_MACHINE))

{

return E_FAIL;

}

if (!RegisterComClasses(HKEY_LOCAL_MACHINE, false))

{

return E_FAIL;

}

return S_OK;

}

STDMETHODIMP ExeUnregisterServer()

{

if (!UnregisterComClasses(HKEY_LOCAL_MACHINE))

{

return E_FAIL;

}

if (!UnregisterTypeLib(HKEY_LOCAL_MACHINE))

{

return E_FAIL;

}

return S_OK;

}

对于PerUser的情形，只需要把四处HKEY_LOCAL_MACHINE换成HKEY_CURRENT_USER就好了，不过现在我们先不管这些。

然后我们转到入口函数WinMain，加上对/RegServer和/UnregServer的处理：

int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,

_In_opt_ HINSTANCE hPrevInstance,

_In_ LPTSTR lpCmdLine,

_In_ int nCmdShow)

{

xl::g_pComModule = new xl::ComModule(hInstance, _T("Streamlet COMProvider TypeLib 1.0"));

if (_tcsicmp(lpCmdLine, _T("/RegServer")) == 0 || _tcsicmp(lpCmdLine, _T("-RegServer")) == 0)

{

xl::g_pComModule->ExeRegisterServer();

}

else if (_tcsicmp(lpCmdLine, _T("/UnregServer")) == 0 || _tcsicmp(lpCmdLine, _T("-UnregServer")) == 0)

{

xl::g_pComModule->ExeUnregisterServer();

}

delete xl::g_pComModule;

return 0;

}

到目前为止，可以编译程序，把组件注册上了。

进程外COM的启动

进程外COM的启动大致有如下几步：

1. 初始化COM库。

2. 使用CoRegisterClassObject向COM库注册类厂。

3. 跑一个消息循环，并自己控制退出。

4. 调用CoRevokeClassObject向COM库注消类厂。（Revoke这个名字也不喜欢，一般与Register对应的都是Unregister。）

5. 反初始化COM库。

6. 退出。

我们将WinMain改成如下的样子：

int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,

_In_opt_ HINSTANCE hPrevInstance,

_In_ LPTSTR lpCmdLine,

_In_ int nCmdShow)

{

xl::g_pComModule = new xl::ComModule(hInstance, _T("Streamlet COMProvider TypeLib 1.0"));

if (_tcsicmp(lpCmdLine, _T("/RegServer")) == 0 || _tcsicmp(lpCmdLine, _T("-RegServer")) == 0)

{

xl::g_pComModule->ExeRegisterServer();

}

else if (_tcsicmp(lpCmdLine, _T("/UnregServer")) == 0 || _tcsicmp(lpCmdLine, _T("-UnregServer")) == 0)

{

xl::g_pComModule->ExeUnregisterServer();

}

else if (_tcsicmp(lpCmdLine, _T("/Embedding")) == 0 || _tcsicmp(lpCmdLine, _T("-Embedding")) == 0)

{

HRESULT hr = xl::g_pComModule->ExeRegisterClassObject();

if (SUCCEEDED(hr))

{

MSG msg = {};

while (GetMessage(&msg, nullptr, 0, 0))

{

TranslateMessage(&msg);

DispatchMessage(&msg);

}

xl::g_pComModule->ExeUnregisterClassObject();

}

delete xl::g_pComModule;

return 0;

}

我们将在ComModule::ExeRegisterClassObject里完成1、2，在ComModule::ExeUnregisterClassObject里完成4、5。

ComModule::ExeRegisterClassObject

之前为了注册COM类，我们已经保存了对象表，里面有每一个对外暴露的类的CLSID、类厂创建函数指针等。我们找到每一个要注册的类，创建类厂，然后调用CoRegisterClassObject。CoRegisterClassObject将返回一个DWORD值（Cookie），用于唯一确定所注册的类，在CoRevokeClassObject的时候要用到，所以要保存起来。CoRegisterClassObject内部会将我们传给它的类厂的引用计数加一，我们应该把自己产生的引用计数都释放掉，整个COM组件运行期间，类厂引用计数始终维持在1，就是COM库占用的那个。

代码如下：

STDMETHODIMP ExeRegisterClassObject()

{

HRESULT hr = CoInitialize(nullptr);

if (FAILED(hr))

{

return hr;

}

for (const ClassEntry * const *ppEntry = &LP_CLASS_BEGIN + 1; ppEntry < &LP_CLASS_END; ++ppEntry)

{

if (*ppEntry == nullptr)

{

continue;

}

IClassFactory *pClassFactory = (*ppEntry)->pfnCreator();

if (pClassFactory == nullptr)

{

return E_FAIL;

}

IUnknown *pUnk = nullptr;

HRESULT hr = pClassFactory->QueryInterface(__uuidof(IUnknown), (LPVOID *)&pUnk);

if (FAILED(hr) || pUnk == nullptr)

{

return hr;

}

DWORD dwRegister = 0;

hr = CoRegisterClassObject(*(*ppEntry)->pClsid,

pUnk,

CLSCTX_LOCAL_SERVER,

REGCLS_MULTIPLEUSE,

&dwRegister);

pUnk->Release();

if (FAILED(hr))

{

return hr;

}

m_arrRegClassObjects.PushBack(dwRegister);

}

return S_OK;

}

ComModule::ExeUnregisterClassObject

这个就比较简单了，针对上面保存的Cookie，调用CoRevokeClassObject即可。CoRevokeClassObject会调用类厂的Release来释放COM库占用的那个引用计数。

STDMETHODIMP ExeUnregisterClassObject()

{

for (auto it = m_arrRegClassObjects.Begin(); it != m_arrRegClassObjects.End(); ++it)

{

CoRevokeClassObject(*it);

}

m_arrRegClassObjects.Clear();

CoUninitialize();

return S_OK;

}

进程外COM的使用

通过上面几个步骤，我们的进程外COM组件已经可以被使用了。为了检验参数的序列化/反序列化是否正确，我们稍稍地改变下接口ISampleInterface，加些参数：

[

object,

uuid(83C783E3-F989-4E0D-BFC5-631273EDFFDB),

dual,

]

interface ISampleInterface : IDispatch

{

[id(1)] HRESULT SampleMethod([in] BSTR bstrMessage, [out] LONG *pResult);

};

并实现如下：

STDMETHODIMP SampleClass::SampleMethod(BSTR bstrMessage, LONG *pResult)

{

MessageBox(NULL, bstrMessage, _T("Info"), MB_OK | MB_ICONINFORMATION);

if (pResult != nullptr)

{

*pResult = 12345678;

}

return S_OK;

}

另起一个EXE：

int _tmain(int argc, TCHAR *argv[])

{

HRESULT hr = CoInitialize(NULL);

if (FAILED(hr))

{

return 0;

}

ISampleInterface *pSampleInterface = nullptr;

hr = CoCreateInstance(__uuidof(SampleClass),

nullptr,

CLSCTX_LOCAL_SERVER,

__uuidof(ISampleInterface),

(LPVOID *)&pSampleInterface);

if (SUCCEEDED(hr))

{

BSTR bstrMessage = SysAllocString(_T("COMProvider!SampleClass::SampleMethod Called From COMUser."));

LONG nResult = 0;

pSampleInterface->SampleMethod(bstrMessage, &nResult);

SysFreeString(bstrMessage);

pSampleInterface->Release();

}

CoUninitialize();

return 0;

}

运行结果：

还有一个输出参数值：

一切正常。

但是此时，调用方运行结束后，COM组件还在运行中，没有退出。退出是需要我们手工控制的，下面我们来做这件事。

进程外COM的退出

观察了下ATL的实现，它是在最后一个对象被释放后，触发AtlExeModuleT的Unlock，在其中向主线程发送了一个WM_QUIT，结束消息循环。

我们之前实现进程内组件的时候，也做过DllCanUnloadNow，这里面，有一个对象计数和类厂的锁计数。而由于xl::ComClass在构造的时候就对对象技术进行了加一，所以对象计数包含了类厂的计数，这在进程内组件里没问题，而且也是必须的。因为类厂存在，说明被使用，DLL不该被释放。

而在进程外组件中，由于消息循环结束之前，COM库肯定会占用一个类厂引用计数，如果对象计数包含类厂的话，我们就无法判断发WM_QUIT的时机了。因此，我们这里对xl::ComClass的构造函数和加一个参数，指定需不需要加引用计数，然后分别在DLL创建类厂和EXE创建类厂的时候传入不同的值。

xl::ComClass 构造析构函数修改如下：

ComClass(bool bAddObjRefCount = true) : m_nRefCount(0), m_bAddObjRefCount(bAddObjRefCount)

{

if (g_pComModule != nullptr && m_bAddObjRefCount)

{

g_pComModule->ObjectAddRef();

}

~ComClass()

{

if (g_pComModule != nullptr && m_bAddObjRefCount)

{

g_pComModule->ObjectRelease();

}

类厂构造函数和创建函数修改如下：

static IClassFactory *CreateFactory(bool bAddObjRefCount = true)

{

return new ClassFactory(bAddObjRefCount);

}

ClassFactory(bool bAddObjRefCount = true) :

ComClass<ClassFactory<T>>(bAddObjRefCount)

{

}

xl::ComModule::ExeRegisterClassObject中修改如下：

STDMETHODIMP ExeRegisterClassObject()

{

HRESULT hr = CoInitialize(nullptr);

if (FAILED(hr))

{

return hr;

}

for (const ClassEntry * const *ppEntry = &LP_CLASS_BEGIN + 1; ppEntry < &LP_CLASS_END; ++ppEntry)

{

if (*ppEntry == nullptr)

{

continue;

}

IClassFactory *pClassFactory = (*ppEntry)->pfnCreator(false);

if (pClassFactory == nullptr)

{

return E_FAIL;

}

IUnknown *pUnk = nullptr;

HRESULT hr = pClassFactory->QueryInterface(__uuidof(IUnknown), (LPVOID *)&pUnk);

if (FAILED(hr) || pUnk == nullptr)

{

return hr;

}

DWORD dwRegister = 0;

hr = CoRegisterClassObject(*(*ppEntry)->pClsid,

pUnk,

CLSCTX_LOCAL_SERVER,

REGCLS_MULTIPLEUSE,

&dwRegister);

pUnk->Release();

if (FAILED(hr))

{

return hr;

}

m_arrRegClassObjects.PushBack(dwRegister);

}

m_dwThreadId = GetCurrentThreadId();

return S_OK;

}

注意在最后存了一个Thread ID，这个ID表明当前是处于EXE模式。

然后在xl::ComModule的对象引用计数释放、锁计数释放的函数中判断并发送WM_QUIT：

ULONG STDMETHODCALLTYPE ObjectRelease()

{

ULONG lResult = (ULONG)InterlockedDecrement(&m_nObjectRefCount);

if (m_dwThreadId != 0 && CanUnloadNow())

{

PostThreadMessage(m_dwThreadId, WM_QUIT, 0, 0);

}

return lResult;

}

ULONG STDMETHODCALLTYPE LockRelease()

{

ULONG lResult = (ULONG)InterlockedDecrement(&m_nLockRefCount);

if (m_dwThreadId != 0 && CanUnloadNow())

{

PostThreadMessage(m_dwThreadId, WM_QUIT, 0, 0);

}

return lResult;

}

其中CanUnloadNow跟DllCanUnloadNow的判断是一致的，于是乎合并起来：

bool CanUnloadNow()

{

if (m_nObjectRefCount > 0 || m_nLockRefCount > 0)

{

return false;

}

return true;

}

STDMETHODIMP DllCanUnloadNow()

{

return CanUnloadNow() ? S_OK : S_FALSE;

}

好了，代码实现全部结束。

从不同语言调用

WSH+VBScript

和以前差不多，也写个VBS脚本：

Set obj = WScript.CreateObject("Streamlet.COMProvider.SampleClass.1")

obj.SampleMethod "Hello! Calling from VBScript.", 0

运行结果：

Visual Basic 6

VB6代码：

Private Sub Command1_Click()

Dim obj As Object

Set obj = CreateObject("Streamlet.COMProvider.SampleClass.1")

obj.SampleMethod "Hello! Calling from VB6.", 0

Set obj = Nothing

End Sub

运行结果：

网页中的Javascript

JS代码如下：

var objCom = new ActiveXObject("Streamlet.COMProvider.SampleClass.1");

objCom.SampleMethod("Hello! Calling from JavaScript.", 0);

</script>

运行结果：

遗憾的是，从网页调用后，COM组件似乎没法退出。查了下，貌似是JS释放对象机制的问题。

本文例子代码见：COMProtocol5.rar（http://pan.baidu.com/s/1dD3ZzUD）

posted on 2012-12-02 19:56 溪流阅读(7152) 评论(1) 编辑收藏引用所属分类: C++ 、Windows 、COM

只有注册用户登录后才能发表评论。
【推荐】100%开源！大型工业跨平台软件C++源码提供，建模，组态！

相关文章: 建立一个简单干净的 gn+ninja 工具链微软拼音长句模式恢复工具支持Win10 1803 发布个工具，一键恢复Win8/8.1中的微软拼音长句模式（新体验模式）将 Timer 对象化裸写一个进程外 COM 组件让 COM 脱离注册表在 DLL 中加入第二个 COM 类让COM组件可被跨语言调用裸写一个进程内 COM 组件写个含 Windows Media Player 的窗口

网站导航: 博客园 IT新闻 BlogJava 知识库博问管理

引言

命令行规范

注册和反注册

进程外COM的启动

ComModule::ExeRegisterClassObject

ComModule::ExeUnregisterClassObject

进程外COM的使用

进程外COM的退出

从不同语言调用

WSH+VBScript

Visual Basic 6

网页中的Javascript

常用链接

留言簿(21)

随笔分类(124)

随笔档案(90)

我的链接

友情链接

积分与排名

最新随笔

最新评论

阅读排行榜

评论排行榜