COM编程入门__不可多得的资料

COM编程入门:第一部分 什么是COM，如何使用COM

转自： http://www.vckbase.com/index.php/wv/144.html

   原文：http://www.codeproject.com/Articles/633/Introduction-to-COM-What-It-Is-and-How-to-Use-It

       本文的目的是为刚刚接触COM的程序员提供编程指南，并帮助他们理解COM的基本概念。内容包括COM规范简介，重要的COM术语以及如何重用现有的COM组件。本文不包括如何编写自己的COM对象和接口。

          COM即组件对象模型，是Component ObjectModel 取前三个字母的缩写，这三个字母在当今Windows的世界中随处可见。随时涌现出来的大把大把的新技术都以COM为基础。各种文档中也充斥着诸如COM对象、接口、服务器之类的术语。因此，对于一个程序员来说，不仅要掌握使用COM的方法，而且还要彻底熟悉COM的所有一切。

         本文由浅入深描述COM的内在运行机制，教你如何使用第三方提供的COM对象（以Windows 外壳组件Shell为例）。读完本文后，你就能掌握如何使用Windows操作系统中内建的组件和第三方提供的COM对象。

本文假设你精通C++语言。在例子代码中使用了一点MFC和ATL，如果你不熟悉MFC和ATL也没关系，本文会对这些代码进行完全透彻的解释。本文包括以下几个部分：

•   COM――到底是什么？――COM标准的要点介绍，它被设计用来解决什么问题
•   基本元素的定义――COM术语以及这些术语的含义
•   使用和处理COM对象――如何创建、使用和销毁COM对象
•   基本接口――描述IUnknown基本接口及其方法
•   掌握串的处理――在COM代码中如何处理串
•   应用COM技术――例子代码，举例说明本文所讨论的所有概念
•   处理HRESULT――HRESULT类型描述，如何监测错误及成功代码

COM到底是什么

 

       简单地说，COM是一种跨应用和语言共享二进制代码的方法。与C++不同，它提倡源代码重用。ATL便是一个很好的例证。源码级重用虽然好，但只能用于C++。它还带来了名字冲突的可能性，更不用说不断拷贝重用代码而导致工程膨胀和臃肿。

        Windows使用DLLs在二进制级共享代码。这也是Windows程序运行的关键――重用kernel32.dll, user32.dll等。但DLLs是针对C接口而写的，它们只能被C或理解C调用规范的语言使用。由编程语言来负责实现共享代码，而不是由DLLs本身。这样的话DLLs的使用受到限制。
MFC引入了另外一种MFC扩展DLLs二进制共享机制。但它的使用仍受限制――只能在MFC程序中使用。

        COM通过定义二进制标准解决了这些问题，即COM明确指出二进制模块（DLLs和EXEs）必须被编译成与指定的结构匹配。这个标准也确切规定了在内存中如何组织COM对象。COM定义的二进制标准还必须独立于任何编程语言（如C++中的命名修饰）。一旦满足了这些条件，就可以轻松地从任何编程语言中存取这些模块。由编译器负责所产生的二进制代码与标准兼容。这样使后来的人就能更容易地使用这些二进制代码。

       在内存中，COM对象的这种标准形式在C++虚函数中偶尔用到，所以这就是为什么许多COM代码使用C++的原因。但是记住，编写模块所用的语言是无关的，因为结果二进制代码为所有语言可用。

       此外，COM不是Win32特有的。从理论上讲，它可以被移植到Unix或其它操作系统。但是我好像还从来没有在Windows以外的地方听说过COM。

基本元素的定义

        我们从下往上看。接口只不过是一组函数。这些函数被称为方法。接口名字以大写的I开头，例如C++中的IShellLink，接口被设计成一个抽象基类，其中只有纯粹的虚拟函数。

        接口可以从其它接口继承，这里所说的继承的原理就好像C++中的单继承。接口是不允许多继承的。

        coclass（简称组件对象类――componentobject class）被包含在DLL或EXE中，并且包含着一个或者多个接口的代码。组件对象类（coclasss）实现这些接口。COM对象在内存中表现为组件对象类（coclasss）的一个实例。注意COM“类”和C++“类”是不相同的，尽管常常COM类实现的就是一个C++类。

       COM服务器是包含了一个或多个coclass的二进制（DLL或EXE）。

       注册（Registration）是创建注册表入口的一个过程，告诉Windows 操作系统COM服务器放在什么位置。取消注册（Unregistration）则相反――从注册表删除这些注册入口。

        GUID（谐音为“fluid”，意思是全球唯一标示符――globally unique identifier）是个128位的数字。它是一种独立于COM编程语言的标示方法。每一个接口和coclass有一个GUID。因为每一个GUID都是全球唯一的，所以避免了名字冲突（只要你用COM API创建它们）。有时你还会碰到另一个术语UUID（意思也是全球唯一标示符――universally unique identifier）。UUIDs和GUIDs在实际使用时的用途是一样的。

        类ID或者CLSID是命名coclass的GUID。接口ID或者IID是命名接口的GUID。

       在COM中广泛地使用GUID有两个理由：

        1.GUIDs只是简单的数字，任何编程语言都可以对之进行处理；

        2.GUIDs可以在任何机器上被任何人创建，一旦完成创建，它就是唯一的。因此，COM开发人员可以创建自己特有的GUIDs而不会与其它开发人员所创建的GUIDs有冲突。这样就消除了集中授权发布GUIDs的必要。

        HRESULT是COM用来返回错误和成功代码的整型数字。除此之外，别无它意，虽然以H作前缀，但没有句柄之意。下文会对它有更多的讨论。

最后，COM库是在你使用COM时与你交互的操作系统的一部分，它常常指的就是COM本身。但是为了避免混淆才分开描述的。

使用和处理COM对象

 

       每一种语言都有其自己处理对象的方式。例如，C++是在栈中创建对象，或者用new动态分配。因为COM必须独立于语言，所以COM库为自己提供对象管理例程。下面是对COM对象管理和C++对象管理所做的一个比较：

创建一个新对象

         C++中，用new操作符，或者在栈中创建对象。

         COM中，调用COM库中的API。

删除对象

          C++中，用delete操作符，或将栈对象踢出。

          COM中，所有的对象保持它们自己的引用计数。调用者必须通知对象什么时候用完这个对象。当引用计数为零时，COM对象将自己从内存中释放。

         由此可见，对象处理的两个阶段：创建和销毁，缺一不可。当创建COM对象时要通知COM库使用哪一个接口。如果这个对象创建成功，COM库返回所请求接口的指针。然后通过这个指针调用方法，就像使用常规C++对象指针一样。

创建COM对象

         为了创建COM对象并从这个对象获得接口，必须调用COM库的API函数，CoCreateInstance()。其原型如下：

[cpp]  view plain copy print ?

1. HRESULT CoCreateInstance (  
2. REFCLSID  rclsid,  
3. LPUNKNOWN pUnkOuter,  
4. DWORD     dwClsContext,  
5. REFIID    riid,  
6. LPVOID*   ppv );  

以下是参数解释：

1.rclsid：coclass的CLSID，例如，可以传递CLSID_ShellLink创建一个COM对象来建立快捷方式。

2.pUnkOuter：这个参数只用于COM对象的聚合，利用它向现有的coclass添加新方法。参数值为null表示不使用聚合。

3.dwClsContext：表示所使用COM服务器的种类。本文使用的是最简单的COM服务器，一个进程内（in-process）DLL，

4.　　　　　　　　所以传递的参数值为CLSCTX_INPROC_SERVER。注意这里不要随意使用CLSCTX_ALL（在ATL中，它是个缺省值），

5.　　　　　　　　因为在没有安装DCOM的Windows95系统上会导致失败。

6.riid：请求接口的IID。例如，可以传递IID_IShellLink获得IShellLink接口指针。

7.ppv：接口指针的地址。COM库通过这个参数返回请求的接口。     

          当你调用CoCreateInstance()时，它负责在注册表中查找COM服务器的位置，将服务器加载到内存，并创建你所请求的coclass实例。以下是一个调用的例子，创建一个CLSID_ShellLink对象的实例并请求指向这个对象IShellLink接口指针。

[cpp]  view plain copy print ?

1. HRESULT     hr;  
2. IShellLink* pISL;  
3.  hr = CoCreateInstance ( CLSID_ShellLink,         //coclass 的CLSID  
4. NULL,                    //不是用聚合  
5. CLSCTX_INPROC_SERVER,    //服务器类型  
6. IID_IShellLink,          //接口的IID  
7.  (void**)&pISL );        // 指向接口的指针  
8. if ( SUCCEEDED ( hr ) )  
9. {  
10. // 用pISL调用方法  
11. }  
12. else  
13. {  
14. // 不能创建COM对象，hr 为出错代码  
15. }  

         首先声明一个接受CoCreateInstance()返回值的HRESULT和IShellLink指针。调用CoCreateInstance()来创建新的COM对象。如果hr接受到一个表示成功的代码，则SUCCEEDED宏返回TRUE，否则返回FALSE。FAILED是一个与SUCCEEDED对应的宏用来检查失败代码。

删除COM对象

         前面说过，你不用释放COM对象，只要告诉它们你已经用完对象。IUnknown是每一个COM对象必须实现的接口，它有一个方法，Release()。调用这个方法通知COM对象你不再需要对象。一旦调用了这个方法之后，就不能再次使用这个接口，因为这个COM对象可能从此就从内存中消失了。

          如果你的应用程序使用许多不同的COM对象，因此在用完某个接口后调用Release()就显得非常重要。如果你不释放接口，这个COM对象（包含代码的DLLs）将保留在内存中，这会增加不必要的开销。如果你的应用程序要长时间运行，就应该在应用程序处于空闲期间调用CoFreeUnusedLibraries() API。这个API将卸载任何没有明显引用的COM服务器，因此这也降低了应用程序使用的内存开销。

          继续用上面的例子来说明如何使用Release()：

[cpp]  view plain copy print ?

1. // 像上面一样创建COM 对象， 然后，  
2.  if ( SUCCEEDED ( hr ) )  
3. {  
4.      // 用pISL调用方法  
5.      // 通知COM 对象不再使用它  
6.      pISL->Release();  
7. }  

  接下来将详细讨论IUnknown接口

基本接口――IUnknown

         每一个COM接口都派生于IUnknown。这个名字有点误导人，其中没有未知（Unknown）接口的意思。它的原意是如果有一个指向某COM对象的IUnknown指针，就不用知道潜在的对象是什么，因为每个COM对象都实现IUnknown。IUnknown有三个方法：

AddRef() ―― 通知COM对象增加它的引用计数。如果你进行了一次接口指针的拷贝，就必须调用一次这个方法，并且原始的值和拷贝的值两者都要用到。在本文的例子中没有用到AddRef()方法；

        Release() ―― 通知COM对象减少它的引用计数。参见前面的Release()示例代码段；

        QueryInterface() ―― 从COM对象请求一个接口指针。当coclass实现一个以上的接口时，就要用到这个方法；

         前面已经看到了Release()的使用，但如何使用QueryInterface()呢?当你用CoCreateInstance()创建对象的时候，你得到一个返回的接口指针。如果这个COM对象实现一个以上的接口（不包括IUnknown），你就必须用QueryInterface()方法来获得任何你需要的附加的接口指针。QueryInterface()的原型如下：

[cpp]  view plain copy print ?

1. HRESULT IUnknown::QueryInterface (  
2. REFIID iid,  
3. void** ppv );  

以下是参数解释：

1.iid：所请求的接口的IID。

2.ppv：接口指针的地址，QueryInterface()通过这个参数在成功时返回这个接口。

        让我们继续外壳链接的例子。它实现了IShellLink和IPersistFile接口。如果你已经有一个IShellLink指针，pISL，可以从COM对象请求IPersistFile接口：

[cpp]  view plain copy print ?

1. HRESULT hr;  
2. IPersistFile* pIPF;  
3. hr = pISL->QueryInterface (IID_IPersistFile, (void**) &pIPF );  

         然后使用SUCCEEDED宏检查hr的值以确定QueryInterface()的调用情况，如果成功的话你就可以象使用其它接口指针那样使用新的接口指针，pIPF。但必须记住调用pIPF->Release()通知COM对象已经用完这个接口。

仔细做好串处理

         这一部分将花点时间来讨论如何在COM代码中处理串。如果你熟悉Unicode 和ANSI，并知道如何对它们进行转换的话，你就可以跳过这一部分，否则还是读一下这一部分的内容。

         不管什么时候，只要COM方法返回一个串，这个串都是Unicode串（这里指的是写入COM规范的所有方法）。Unicode是一种字符编码集，类似ASCII，但用两个字节表示一个字符。如果你想更好地控制或操作串的话，应该将它转换成TCHAR类型串。

          TCHAR和以_t开头的函数（如_tcscpy()）被设计用来让你用相同的源代码处理Unicode和ANSI串。在大多数情况下编写的代码都是用来处理ANSI串和ANSI WindowsAPIs，所以在下文中，除非另外说明，我所说的字符/串都是指TCHAR类型。你应该熟练掌握TCHAR类型，尤其是当你阅读其他人写的有关代码时，要特别注意TCHAR类型。

          当你从某个COM方法返回得到一个Unicode串时，可以用下列几种方法之一将它转换成char类型串：

1. 调用 WideCharToMultiByte()API；
2. 调用CRT 函数wcstombs()；
3. 使用CString 构造器或赋值操作(仅用于MFC )；
4. 使用ATL 串转换宏；

1.WideCharToMultiByte()

 

       你可以用WideCharToMultiByte()将一个Unicode串转换成一个ANSI串。此函数的原型如下：

[cpp]  view plain copy print ?

1. int WideCharToMultiByte (  
2. UINT    CodePage,  
3. DWORD   dwFlags,  
4. LPCWSTR lpWideCharStr,  
5. int     cchWideChar,  
6. LPSTR   lpMultiByteStr,  
7. int     cbMultiByte,  
8. LPCSTR  lpDefaultChar,  
9. LPBOOL  lpUsedDefaultChar );  

以下是参数解释：

 CodePage：Unicode字符转换成的代码页。你可以传递CP_ACP来使用当前的ANSI代码页。代码页是256个字符集。字符0――127与ANSI编码一样。字符128――255与ANSI字符不同，它可以包含图形字符或者读音符号。每一种语言或地区都有其自己的代码页，所以使用正确的代码页对于正确地显示重音字符很重要。

dwFlags：dwFlags 确定Windows如何处理“复合” Unicode字符，它是一种后面带读音符号的字符。

如è就是一个复合字符。如果这些字符在CodePage参数指定的代码页中，不会出什么事。

否则，Windows必须对之进行转换。传递WC_COMPOSITECHECK使得这个API检查非映射复合字符。

传递WC_SEPCHARS使得Windows将字符分为两段，即字符加读音，如e`。

传递WC_DISCARDNS使得Windows丢弃读音符号。

传递WC_DEFAULTCHAR使得Windows用lpDefaultChar参数中说明的缺省字符替代复合字符。

缺省行为是WC_SEPCHARS。

lpWideCharStr 要转换的Unicode串。

cchWideChar lpWideCharStr在Unicode 字符中的长度。通常传递-1，表示这个串是以0x00结尾。

lpMultiByteStr 接受转换的串的字符缓冲 cbMultiBytelpMultiByteStr的字节大小。

lpDefaultChar 可选――当dwFlags包含WC_COMPOSITECHECK | WC_DEFAULTCHAR并且某个Unicode字符不能被映射到同等的ANSI串时所传递的一个单字符ANSI串，包含被插入的“缺省”字符。可以传递NULL，让API使用系统缺省字符（一种写法是一个问号）。

lpUsedDefaultChar 可选――指向BOOL类型的一个指针，设置它来表示是否缺省字符曾被插入ANSI串。可以传递NULL来忽略这个参数。

            我自己都有点晕菜了……!，万事开头难啊……，不搞清楚这些东西就很难搞清楚COM的串处理。何况文档中列出的比实际应用的要复杂得　多。下面就给出了如何使用这个API的例子：

[cpp]  view plain copy print ?

1. // 假设已经有了一个Unicode 串 wszSomeString...  
2. char szANSIString[MAX_PATH];  
3. WideCharToMultiByte (CP_ACP,                //ANSI 代码页  
4. WC_COMPOSITECHECK, // 检查重音字符  
5. wszSomeString,         //原Unicode 串  
6. -1,                    //-1 意思是串以0x00结尾  
7. szANSIString,          //目的char字符串  
8. sizeof(szANSIString),  // 缓冲大小  
9. NULL,                  //肥缺省字符串  
10. NULL);                //忽略这个参数  

调用这个函数后，szANSIString将包含Unicode串的ANSI版本。调用这个函数后，szANSIString将包含Unicode串的ANSI版本。

2.wcstombs()

 

      这个CRT函数wcstombs()是个简化版，但它终结了WideCharToMultiByte()的调用，所以最终结果是一样的。其原型如下：

[cpp]  view plain copy print ?

1. size_t wcstombs (  
2. char*         mbstr,  
3. const wchar_t* wcstr,  
4. size_t         count );  

以下是参数解释：

1.mbstr：接受结果ANSI串的字符（char）缓冲。

2.wcstr：要转换的Unicode串。

3.count：mbstr参数所指的缓冲大小。

         wcstombs()在它对WideCharToMultiByte()的调用中使用WC_COMPOSITECHECK | WC_SEPCHARS标志。用wcstombs()转换前面例子中的   Unicode串，结果一样：

[cpp]  view plain copy print ?

1. wcstombs ( szANSIString, wszSomeString, sizeof(szANSIString));  

3.CString

 

    MFC中的CString包含有构造函数和接受Unicode串的赋值操作，所以你可以用CString来实现转换。例如：

[cpp]  view plain copy print ?

1. // 假设有一个Unicode串wszSomeString...  
2.  CString str1 ( wszSomeString ); // 用构造器转换  
3.  CString str2;  
4.  str2 = wszSomeString; // 用赋值操作转换  

4.ATL宏

        ATL有一组很方便的宏用于串的转换。W2A()用于将Unicode串转换为ANSI串（记忆方法是“wide to ANSI”――宽字符到ANSI）。实际上使用OLE2A()更精确，“OLE”表示的意思是COM串或者OLE串。下面是使用这些宏的例子：

[cpp]  view plain copy print ?

1. // 还是假设有一个Unicode串wszSomeString...  
2. {  
3. char szANSIString[MAX_PATH];  
4. USES_CONVERSION; // 声明这个宏要使用的局部变量  
5. lstrcpy ( szANSIString, OLE2A(wszSomeString));  
6. }  

        OLE2A()宏“返回”转换的串的指针，但转换的串被存储在某个临时栈变量中，所以要用lstrcpy()来获得自己的拷贝。其它的几个宏是W2T()（Unicode 到 TCHAR）以及W2CT()（Unicode到常量TCHAR串）。

         有个宏是OLE2CA()（Unicode到常量char串），可以被用到上面的例子中，OLE2CA()实际上是个更正宏，因为lstrcpy()的第二个参数是一个常量char*，关于这个问题本文将在以后作详细讨论。

         另一方面，如果你不想做以上复杂的串处理，尽管让它还保持为Unicode串，如果编写的是控制台应用程序，输出/显示Unicode串时应该用全程变量std::wcout，如：

[cpp]  view plain copy print ?

1. <span style="font-family:SimSun;">wcout << wszSomeString;</span>  

        但是要记住，std::wcout只认Unicode，所以你要是“正常”串的话，还得用std::cout输出/显示。对于Unicode串文字量，要使用前缀L标示，如：

[cpp]  view plain copy print ?

1. <span style="font-family:SimSun;">wcout << L"The Oraclesays..." << endl << wszOracleResponse;</span>  

 如果保持串为Unicode，编程时有两个限制：

 

       必须使用wcsXXX() Unicode串处理函数，如wcslen()；

        在Windows 9x环境中不能在Windows API中传递Unicode串。要想编写能在9x和NT上都能运行的应用，必须使用TCHAR类型，详情请参考MSDN；

用例子代码总结上述内容

         下面用两个例子演示本文所讲的COM概念。代码中还包含了本文的例子工程。

使用单接口COM对象

          第一个例子展示的是单接口COM对象。这可能是你碰到得最简单的例子。它使用外壳中的活动桌面组件对象类（CLSID_ActiveDesktop）来获得当前桌面墙纸的文件名。请确认系统中安装了活动桌面（Active Desktop）。以下是编程步骤：

1. 初始化COM库。 （Initialize）；
2. 创建一个与活动桌面交互的COM对象，并取得IActiveDesktop接口；
3. 调用COM对象的GetWallpaper()方法；
4. 如果GetWallpaper()成功，则输出/显示墙纸文件名；
5. 释放接口（Release()）；
6. 收回COM库（Uninitialize）；

[cpp]  view plain copy print ?

1. WCHAR   wszWallpaper [MAX_PATH];  
2. CString strPath;  
3. HRESULT hr;  
4. IActiveDesktop* pIAD;  
5. // 1. 初始化COM库（让Windows加载DLLs）。通常是在程序的InitInstance()中调用  
6. // CoInitialize ( NULL )或其它启动代码。MFC程序使用AfxOleInit()。  
7. CoInitialize ( NULL );  
8. // 2. 使用外壳提供的活动桌面组件对象类创建COM对象。  
9. // 第四个参数通知COM需要什么接口(这里是IActiveDesktop).  
10.  hr = CoCreateInstance ( CLSID_ActiveDesktop,  
11. NULL,  
12. CLSCTX_INPROC_SERVER,  
13. IID_IActiveDesktop,  
14. (void**) &pIAD );  
15. if ( SUCCEEDED(hr) )  
16. {  
17.            // 3. 如果COM对象被创建成功，则调用这个对象的GetWallpaper() 方法。  
18.             hr = pIAD->GetWallpaper ( wszWallpaper,MAX_PATH, 0 );  
19.            if ( SUCCEEDED(hr) )  
20.            {  
21.                      // 4. 如果 GetWallpaper() 成功，则输出它返回的文件名字。  
22.                     // 注意这里使用wcout 来显示Unicode 串wszWallpaper. wcout 是  
23.                     // Unicode 专用，功能与cout.相同。  
24.                     wcout << L"Wallpaper pathis:\n    " << wszWallpaper<< endl << endl;}  
25.            else  
26.           {  
27.                          cout << _T("GetWallpaper()failed.") << endl << endl;  
28.              }  
29.           // 5. 释放接口。  
30.            pIAD->Release();  
31. }  
32. else  
33. {  
34.              cout << _T("CoCreateInstance()failed.") << endl << endl;  
35. }  
36. // 6. 收回COM库。MFC 程序不用这一步，它自动完成。  
37. 　　CoUninitialize();  

         在这个例子中，输出/显示Unicode 串 wszWallpaper用的是std::wcout。

使用多接口的COM对象

 

         第二个例子展示了如何使用一个提供单接口的COM对象QueryInterface()函数。其中的代码用外壳的Shell Link组件对象类创建我们在第一个例子中获得的墙纸文件的快捷方式。以下是编程步骤：

1. 初始化 COM 库；
2. 创建一个用于建立快捷方式的COM 对象并取得IShellLink 接口；
3. 调用IShellLink 接口的SetPath()方法；
4. 调用对象的QueryInterface()函数并取得IPersistFile接口；
5. 调用IPersistFile 接口的Save()方法；
6. 释放接口；
7. 收回COM库；

[cpp]  view plain copy print ?

1. CString      sWallpaper = wszWallpaper;  // 将墙纸路径转换为ANSI  
2. IShellLink*   pISL;  
3. IPersistFile* pIPF;  
4.  // 1. 初始化COM库(让Windows 加载DLLs). 通常在InitInstance()中调用  
5. // CoInitialize ( NULL )或其它启动代码。MFC 程序使用AfxOleInit()。  
6. CoInitialize ( NULL );  
7. // 2. 使用外壳提供的Shell Link组件对象类创建COM对象。.  
8. // 第四个参数通知COM 需要什么接口(这里是IShellLink)。   
9. hr = CoCreateInstance ( CLSID_ShellLink,NULL,CLSCTX_INPROC_SERVER,IID_IShellLink,(void**)&pISL );  
10. if ( SUCCEEDED(hr) )  
11. {  
12.       // 3. 设置快捷方式目标(墙纸文件)的路径。  
13.       hr = pISL->SetPath ( sWallpaper );  
14.       if ( SUCCEEDED(hr) )  
15.       {  
16.               // 4. 获取这个对象的第二个接口(IPersistFile)。  
17.                hr = pISL->QueryInterface (IID_IPersistFile, (void**) &pIPF );   
18.                if ( SUCCEEDED(hr) )  
19.                {  
20.                       // 5. 调用Save() 方法保存某个文件得快捷方式。第一个参数是  
21.                       // Unicode 串。  
22.                       hr = pIPF->Save (L"C:\\wallpaper.lnk", FALSE );  
23.                       // 6a. 释放IPersistFile 接口。  
24.                       pIPF->Release();  
25.                 }  
26.        }  
27.        // 6. 释放IShellLink 接口。  
28.        pISL->Release();  
29. }  
30. // 输出错误信息部分这里省略。  
31. // 7. 收回COM 库。MFC 程序不用这一步，它自动完成。  
32. CoUninitialize();  

处理HRESULT

        这一部分准备用SUCCEEDED 和 FAILED宏进行一些简单的出错处理。主要是深入研究从COM方法返回的HRESULT，以便达到完全理解和熟练应用。

        HRESULT是个32位符号整数，其非负值表示成功，负值表示失败。HRESULT有三个域：程度位（表示成功或失败），功能码和状态码。功能码表示HRESULT来自什么组件或程序。微软给不同的组件多赋予功能码，如：COM、任务调度程序等都有功能码。功能码是个16位的值，仅此而已，没         有其它内在含义；它在数字和意义之间是随意关联的；类似GetLastError()返回的值。

        如果你在winerror.h头文件中查找错误代码，会看到许多按照[功能]_[程度]_[描述]命名规范列出的HRESULT值，由组件返回的通用的 HRESULT（类似E_OUTOFMEMORY）在名字中没有功能码。如 ：

REGDB_E_READREGDB：

功能码 = REGDB, 指“注册表数据库（registry database）”；

程度 = E 意思是错误（error）；

描述 = READREGDB 是对错误的描述（意思是不能读注册表数据库）。 S_OK: 没有功能码――通用（generic）

HRESULT；

程度=S；表示成功（success）；

OK 是状态描述表示一切都好（everything''sOK）。

         好在有一种比察看winerror.h文件更容易的方法来确定HRESULT的意思。使用VC提供的错误查找工具（Error Lookup）可以轻松查到为HRESULT内建功能码。例如，假设你在CoCreateInstance()之前忘了调用CoInitialize()。CoCreateInstance()返回的值是0x800401F0。你只要将这个值输入到错误查找工具按“Look Up”按钮，便可以看到错误信息描述“尚未调用CoInitialize”如下图所示：

        另外一种查找HRESULT描述的方法是在调试器中。假设有一个HRESULT变量是hres。在Watch窗口的左边框中输入“hres,hr”，表示想要看的值，“hr”便会通知VC显示HRESULT所描述的值。如下图所示：

         通过以上的讨论，想必你对COM编程有了初步的认识，本文第二部分将探讨COM的内部机制。教你如何用C++编写自己的接口。

（待续）

 

COM编程入门:第二部分 深入COM服务器

本文为刚刚接触COM的程序员提供编程指南，解释COM服务器内幕以及如何用C++编写自己的接口（前一篇博文主要是COM编程的入门：COM编程入门不得不看的文章 ：第一部分 什么是COM，如何使用COM）。继上一篇COM编程入门之后，本文将讨论有关COM服务器的内容，解释编写自己的COM接口和COM服务器所需要的步骤和知识，以及详细讨论当COM库对COM服务器进行调用时，COM服务器运行的内部机制。

如果你读过上一篇文章。应该很熟悉COM客户端是怎么会事了。本文将讨论COM的另一端——COM服务器。内容包括如何用C++编写一个简单的不涉及类库的COM服务器。深入到创建COM服务器的内部过程，毫无遮掩地研究那些库代码是充分理解COM服务器内部机制的最好方法。

本文假设你精通C++并掌握了上一篇文章所讨论的概念和术语。在这一部分将包括如下内容：

•        走马观花看COM服务器——描述COM服务器的基本要求
•        服务器生命其管理——描述COM服务器如何控制加载时间
•        实现接口，从IUnknown 开始——展示如何用C++类编写一个接口实现并描述IUnknown之方法的目的
•       构造器和析构器
•       AddRef() 和 Release()
•       QueryInterface()
•       深入CoCreateInstance()——探究CoCreateInstance()的调用机理
•       COM服务器的注册——描述完成服务器注册所需要的注册表入口
•       创建COM对象——类工厂——描述创建客户端要使用的COM对象的过程
•       一个定制接口的例子——例子代码示范了上述概念
•       一个使用服务器的客户端——举例说明一个简单的客户端应用程序，用它来测试COM服务器
•       其它内容——有关源代码和调试的注释

走马观花看COM服务器

         本文我们将讨论最简单的一种COM服务器，进程内服务器（in-process）。“进程内”意思是服务器被加载到客户端程序的进程空间。进程内服务器都是DLLs，并且与客户端程序同在一台计算机上。进程内服务器在被COM库使用之前必须满足两个条件或标准：

1.必须正确在注册表的HKEY_CLASSES_ROOT\CLSID 键值下注册；

2.必须输出DllGetClassObject()函数；

这是进程内服务器运行的最小需求。在注册表的HKEY_CLASSES_ROOT\CLSID 键值下必须创建一个键值，用服务器的GUID作为键名字，这个键值必须包含两个键值清单，一是服务器的位置，二是服务器的线程模型。 COM库对 DllGetClassObject() 函数进行调用是在CoCreateInstance() API中完成的。

还有三个函数通常也要输出：

• DllCanUnloadNow():由COM库调用来检查是否服务器被从内存中卸载；
• DllRegisterServer():由类似RegSvr32的安装实用程序调用来注册服务器；
• DllUnregisterServer():由卸载实用程序调用来删除由DllRegisterServer()创建的注册表入口；

另外，只输出正确的函数是不够的——还必须遵循COM规范，这样COM库和客户端程序才能使用服务器。

服务器生命其管理

       DLL服务器的一个与众不同的方面是控制它们被加载的时间。“标准的”DLLs被动的并且是在应用程序使用它们时被随机加载/或卸载。从技术上讲，DLL服务器也是被动的，因为不管怎样它们毕尽还是DLL，但COM库提供了一种机制，它允许某个服务器命令COM卸载它。这是通过输出函数DllCanUnloadNow()实现的。这个函数的原型如下：

[cpp]  view plain copy print ?

1. HRESULT DllCanUnloadNow();  

       当客户应用程序调用COM APICoFreeUnusedLibraries()时，通常出于其空闲处理期间，COM库遍历这个客户端应用已加载所有的DLL服务器并通过调用它的DllCanUnloadNow()函数查询每一个服务器。另一方面，如果某个服务器确定它不再需要驻留内存，它可以返回S_OK让COM将它卸载。服务器通过简单的引用计数来确定它是否能被卸载。下面是DllCanUnloadNow()的实现：

[cpp]  view plain copy print ?

1. extern UINT g_uDllRefCount;  // 服务器的引用计数  
2. HRESULT DllCanUnloadNow()  
3. {  
4.     return (g_uDllRefCount > 0) ? S_FALSE : S_OK;  
5. }  

如何处理引用计数将在下一节涉及到具体代码时讨论。

实现接口，从IUnknown开始

       有必要回想一下IUnknown派生的每一个接口。因为IUnknown包含了两个COM对象的基本特性——引用计数和接口查询。当你编写组件对象类时（coclass），还要写一个满足自己需要的IUnknown实现。以实现IUnknown接口的组件对象类为例——下面这个例子可能是你编写的最简单的一个组件对象类。我们将在一个叫做CUnknownImpl的C++类中实现IUnknown。下面是这个类的声明：

[cpp]  view plain copy print ?

1. class CUnknownImpl : public IUnknown  
2. {  
3. public:  
4.     // 构造函数和析构器  
5.     CUnknownImpl();  
6.     virtual ~CUnknownImpl();  
7.   
8.     // IUnknown 方法  
9.     ULONG AddRef();  
10.     ULONG Release)();  
11.     HRESULT QueryInterface( REFIID riid, void** ppv );  
12.   
13. protected:  
14.     UINT m_uRefCount;  // 对象的引用计数  
15. };  

构造器和析构器

构造器和析构器管理服务器的引用计数：

[cpp]  view plain copy print ?

1. CUnknownImpl::CUnknownImpl()  
2. {  
3.     m_uRefCount = 0;  
4.     g_uDllRefCount++;  
5. }  
6.   
7. CUnknownImpl::~CUnknownImpl()  
8. {  
9.     g_uDllRefCount--;  
10. }  

当创建新的COM对象时，构造器被调用，它增加服务器的引用计数以保持这个服务器驻留内存。同时它还将对象的引用计数初始化为零。当这个COM对象被摧毁时，它减少服务器的引用计数。

AddRef() 和 Release()

      这两个方法控制 COM 对象的生命期。AddRef()很简单：

[cpp]  view plain copy print ?

1. ULONG CUnknownImpl::AddRef()  
2. {  
3.     return ++m_uRefCount;  
4. }  

AddRef()只增加对象的引用计数并返回更新的计数。 Release()更简单：

[cpp]  view plain copy print ?

1. ULONG CUnknownImpl::Release()  
2. {  
3. ULONG uRet = --m_uRefCount;  
4.   
5.     if ( 0 == m_uRefCount )  // 是否释放了最后的引用?  
6.         delete this;  
7.   
8.     return uRet;  
9. }  

        除了减少对象的引用计数外，如果没有另外的明确引用，Release()将摧毁对象。Release()也返回更新的引用计数。注意Release()的实现假设COM对象在堆中创建。如果你在全局粘上创建某个对象，当对象试图删除自己时就会出问题。

       现在应该明白了为什么在客户端应用程序中正确调用AddRef()和 Release()是如此重要！如果在这了做得不对，你使用的对象会被很快摧毁，这样的话在整个服务器中内存会很快溢出导致应用程序下次存取服务器代码时崩溃。

      如果你编写多线程应用，可能会想到使用++＆替代InterlockedIncrement()和InterlockedDecrement()的线程安全问题。++＆——用于单线程服务器很保险，因为即使客户端应用是多线程的并从不同的线程中进行方法调用，COM库都会按顺序进行服务器的方法调用。也就是说，一旦一个方法调用开始，所有其它试图调用方法的线程都将阻塞，直到第一个方法返回。COM库本身确保服务器一次不会被一个以上的线程闯入。

QueryInterface()

       QueryInterface()简称QI()，由客户端程序调用这个函数从COM对象请求不同的接口。我们在例子代码中因为只实现一个接口，QI()会很容易使用。QI()有两个参数：一个是所请求的接口IID，一个是指针的缓冲大小，如果查询成功，QI()将接口指针地址存储在这个缓冲指针中。

[cpp]  view plain copy print ?

1. HRESULT CUnknownImpl::QueryInterface ( REFIID riid, void** ppv )  
2. {  
3. HRESULT hrRet = S_OK;  
4.   
5.     // 标准QI()初始化 – 置 *ppv 为 NULL.  
6.     *ppv = NULL;  
7.   
8.     // 如果客户端请求提供的接口，给 *ppv.赋值  
9.     if ( IsEqualIID ( riid, IID_IUnknown ))  
10.         {  
11.         *ppv = (IUnknown*) this;  
12.         }  
13.     else  
14.         {  
15.         // 不提供客户端请求的接口   
16.         hrRet = E_NOINTERFACE;  
17.         }  
18.   
19.     // 如果返回一个接口指针。 调用AddRef()增加引用计数.  
20.     if ( S_OK == hrRet )  
21.         {  
22.         ((IUnknown*) *ppv)->AddRef();  
23.         }  
24.   
25.     return hrRet;  
26. }  

在QI()中做了三件不同的事情：

1.初始化传入的指针为NULL；

[cpp]  view plain copy print ?

1. *ppv =NULL;  

2.检查riid，确定组件对象类（coclass）实现了客户端所请求接口；

[cpp]  view plain copy print ?

1. if (IsEqualIID ( riid, IID_IUnknown ))  

3.如果确实实现勒索请求的接口，则增加COM对象的引用计数。

[cpp]  view plain copy print ?

1. ((IUnknown*) *ppv)->AddRef();  
2. AddRef()调用很关键。  
3.     *ppv = (IUnknown*) this;  

要创建新的COM对象引用，就必须调用这个函数通知COM对象这个新引用成立。在AddRef()调用中的强制转换IUnknown*看起来好像多余，但是在QI()中初始化的*ppv有可能不是IUnknown*类型，所以最好是养成习惯对之进行强行转换。

上面我们已经讨论了一些DLL服务器的内部细节，接下来让我们回头看一看当客户端调用CoCreateInstance()时是如何处理服务器的。

深入CoCreateInstance()

      在本文的第一部分中，我们见过CoCreateInstance()API，其作用是当客户端请求对象时，用它来创建对象。从客户端的立场看，它是一个黑盒子。只要用正确的参数调用它即可得到一个COM对象。它并没有什么魔法，只是在一个定义良好的过程中加载COM服务器，创建请求的COM对象并返回所要的指针。就这些。

下面让我们来浏览一下这个过程。这里要涉及到几个不太熟悉的术语，但不用着急，后面会对它们作详细讨论。

1.客户端程序调用CoCreateInstance()，传递组件对象类的CLSID以及所要接口的IID；

2.COM库在HKEY_CLASSES_ROOT\CLSID.键值下查找服务器的CLSID键值，这个键值包含服务器的注册信息；

3.COM库读取服务器DLL的全路径并将DLL加载到客户端的进程空间；

4.COM库调用在服务器中DllGetClassObject()函数为所请求的组件对象类请求类工厂；

5.服务器创建一个类工厂并将它从DllGetClassObject()返回；

6.COM库在类工厂中调用CreateInstance()方法创建客户端程序请求的COM对象；

7.CreateInstance()返回一个接口指针到客户端程序；

COM服务器注册

       COM 服务器必须在 Windows 注册表中正确注册以后才能正常工作。如果你看一下注册表中的HKEY_CLASSES_ROOT\CLSID 键，就会发现大把大把子键，它们就是在这个计算机上注册的COM服务器。当某个COM服务器注册后（通常是用DllRegisterServer()进行注册），就会以标准的注册表格式在CLSID键下创建一个键，它名字为服务器的GUID。下面是一个这样的例子：

[cpp]  view plain copy print ?

1. {067DF822-EAB6-11cf-B56E-00A0244D5087}  

     大括弧和连字符是必不可少的，字母大小写均可。

     这个键的默认值是人可值别的组件对象类名，使用VC所带的OLE/COM对象浏览器可以察看到它们。在GUID键的子键中还可以存储其它信息。需要创建什么子键依赖于COM服务器的类型以及COM服务器的使用方法。对于本文例子中这个简单的进程内服务器，我们值需要一个子键：InProcServer32。

InProcServer32键包含两个串：这两个串的缺省值是服务器DLL的全路径和线程模型值（ThreadingModel）。线程模型超出了本文所涉及的范围，我们先接受这个概念，这里我们指的是单线程服务器，用的模式为Apartment（即单线程公寓）。

创建COM对象——类工厂

        回首看一看客户端的COM，它是如何以自己独立于语言的方式创建和销毁COM对象。客户端调用CoCreateInstance()创建新的COM对象。现在我们来看看它在服务器端是如何工作的。

       你每次实现组件对象类的时候，都要写一个旁类负责创建第一个组件对象类的实例。这个旁类就叫这个组件对象类的类工厂（class factory），其唯一目的是创建COM对象。之所以要一个类工厂，是因为语言无关的缘故。COM本身并不创建对象，因为它不是独立于语言的也不是独立于实现的。

       当某个客户端想要创建一个COM对象时，COM库就从COM服务器请求类工厂。然后类工厂创建COM对象并将它返回客户端。它们的通讯机制由函数DllGetClassObject()来提供。

       术语 “类工厂”和“类对象”实际上是一回事。没有那个单词能精确描述类工厂的作用和义，但正是这个工厂创建了COM对象，而不是COM类所为。将“类工厂”理解成“对象工厂”可能会更有助于理解（实际上MFC就是这样理解的——它的类工厂实现就叫做COleObjectFactory）。但“类工厂”是正式术语，所以本文也这样用。

      当COM库调用DllGetClassObject()时，它传递客户端请求的CLSID。服务器负责为所请求的CLSID创建者各类工厂并将它返回。类工厂本身就是一个组件对象类，并且实现IClassFactory接口。如果DllGetClassObject()调用成功，它返回一个IClassFactory指针给COM库，然后COM库用IClassFactory接口方法创建客户端所请求的COM对象实例。一下是IClassFactory接口：

[cpp]  view plain copy print ?

1. struct IClassFactory : public IUnknown  
2. {  
3.     HRESULT CreateInstance( IUnknown* pUnkOuter, REFIID riid, void** ppvObject );  
4.     HRESULT LockServer( BOOL fLock );  
5. };  

其中，CreateInstance()是创建COM对象的方法。LockServer()在必要时让COM库增加或减少服务器的引用计数。

一个定制接口的例子

      这个工程是一个能运行的DLL服务器例子，对象由类工厂创建，此DLL服务器在 CSimpleMsgBoxImpl组件对象类中实现了一个接口：ISimpleMsgBox。

接口定义

我们的新接口是ISimpleMsgBox。所有的接口多必须从IUnknown派生。这个接口只有一个方法：DoSimpleMsgBox()。注意它返回标准类型HRESULT。所有的方法都应该返回HRESULT类型，并且所有返回到调用者的其它数据都应该通过指针参数操作。

[cpp]  view plain copy print ?

1. struct ISimpleMsgBox : public IUnknown  
2. {  
3.     // IUnknown 方法  
4.     ULONG AddRef();  
5.     ULONG Release();  
6.     HRESULT QueryInterface( REFIID riid, void** ppv );  
7.   
8.     // ISimpleMsgBox方法  
9.     HRESULT DoSimpleMsgBox( HWND hwndParent, BSTR bsMessageText );  
10. };  
11.   
12. struct __declspec(uuid("{7D51904D-1645-4a8c-BDE0-0F4A44FC38C4}")) ISimpleMsgBox;  

         有__declspec的一行将一个GUID赋值给ISimpleMsgBox，并且以后可以用__uuidof操作符来获取GUID。这两个东西都是微软的C++的扩展。 DoSimpleMsgBox()的第二个参数是BSTR类型。意思是二进制串——即定长序列位的COM表示。BSTRs主要用于Visual Basic 和 Windows Scripting Host之类的脚本客户端。接下来这个接口由CSimpleMsgBoxImpl C++类来实现。其定义如下：

[cpp]  view plain copy print ?

1. class CSimpleMsgBoxImpl : public ISimpleMsgBox    
2. {  
3. public:  
4.     CSimpleMsgBoxImpl();  
5.     virtual ~CSimpleMsgBoxImpl();  
6.   
7.     // IUnknown 方法  
8.     ULONG AddRef();  
9.     ULONG Release();  
10.     HRESULT QueryInterface( REFIID riid, void** ppv );  
11.   
12.     // ISimpleMsgBox 方法  
13.     HRESULT DoSimpleMsgBox( HWND hwndParent, BSTR bsMessageText );  
14.   
15. protected:  
16.     ULONG m_uRefCount;  
17. };  
18.   
19. class  __declspec(uuid("{7D51904E-1645-4a8c-BDE0-0F4A44FC38C4}")) CSimpleMsgBoxImpl;  

当某一客户端想要创建一个SimpleMsgBox COM对象时，它应该用下面这样的代码：

[cpp]  view plain copy print ?

1. ISimpleMsgBox* pIMsgBox;  
2. HRESULT hr;  
3.   
4. // 组件对象类的CLSID   
5. hr = CoCreateInstance ( __uuidof(CSimpleMsgBoxImpl),  
6.        NULL,     // 非聚合  
7.        CLSCTX_INPROC_SERVER, // 进程内服务器  
8.      __uuidof(ISimpleMsgBox), // 所请求接口的IID   
9.     (void**) &pIMsgBox );         // 返回的接口指针的地址  

类工厂实现

      我们的类工厂SimpleMsgBox是在一个叫做CSimpleMsgBoxClassFactory的C++类中实现的：

[cpp]  view plain copy print ?

1. class CSimpleMsgBoxClassFactory : public IClassFactory  
2. {  
3. public:  
4.     CSimpleMsgBoxClassFactory();  
5.     virtual ~CSimpleMsgBoxClassFactory();  
6.   
7.     // IUnknown方法  
8.     ULONG AddRef();  
9.     ULONG Release();  
10.     HRESULT QueryInterface( REFIID riid, void** ppv );  
11.   
12.     // IClassFactory方法  
13.     HRESULT CreateInstance( IUnknown* pUnkOuter, REFIID riid, void** ppv );  
14.     HRESULT LockServer( BOOL fLock );  
15.   
16. protected:  
17.     ULONG m_uRefCount;  
18. };  

构造函数、析构函数和IUnknown方法都和前面例子中的一样，不同的只有IClassFactory的方法，LockServer()，看起来相当更简单：

[cpp]  view plain copy print ?

1. HRESULT CSimpleMsgBoxClassFactory::LockServer ( BOOL fLock )  
2. {  
3.     fLock ? g_uDllLockCount++ : g_uDllLockCount--;  
4.     return S_OK;  
5. }  

CreateInstance()是重点。我们说过这个方法负责创建新的CSimpleMsgBoxImpl对象。让我们进一步探讨一下它的原型和参数：

[cpp]  view plain copy print ?

1. HRESULT CSimpleMsgBoxClassFactory::CreateInstance ( IUnknown* pUnkOuter,  
2.                                                     REFIID    riid,  
3.                                                     void**    ppv );  

      第一个参数pUnkOuter只用于聚合的新对象，指向“外部的”COM对象，也就是说，这个“外部”对象将包含此新对象。对象的聚合超出了本文的讨论范围，本文的例子对象也不支持聚合。riid 和 ppv 与在 QueryInterface() 中的用法一样——它们是客户端所请求的接口IID和存储接口指针的指针缓冲。

     下面是CreateInstance()的实现。它从参数的有效性检查和参数的初始化开始。

[cpp]  view plain copy print ?

1. HRESULT CSimpleMsgBoxClassFactory::CreateInstance ( IUnknown* pUnkOuter,  
2.                                                     REFIID    riid,  
3.                                                     void**    ppv )  
4. {  
5.     // 因为不支持聚合，所以这个参数pUnkOuter必须为NULL.  
6.     if ( NULL != pUnkOuter )  
7.         return CLASS_E_NOAGGREGATION;  
8.   
9.     //检查指针ppv是不是void*类型  
10.     if ( IsBadWritePtr ( ppv, sizeof(void*) ))  
11.         return E_POINTER;  
12.   
13.     *ppv = NULL;  

检查完参数的有效性后，就可以创建一个新的对象了。

[cpp]  view plain copy print ?

1. CSimpleMsgBoxImpl* pMsgbox;  
2.   
3.     // 创建一个新的COM对象  
4.     pMsgbox = new CSimpleMsgBoxImpl;  
5.   
6.     if ( NULL == pMsgbox )  
7.         return E_OUTOFMEMORY;  

       最后，用QI()来查询客户端所请求的新对象的接口。如果QI()失败，则这个对象不可用，必须删除它。

[cpp]  view plain copy print ?

1. HRESULT hrRet;  
2.   
3.     // 用QI查询客户端所请求的对象接口  
4.     hrRet = pMsgbox->QueryInterface ( riid, ppv );  
5.   
6.     // 如果QI失败，则删除这个COM对象，因为客户端不能使用它（客户端没有  
7.     //这个对象的任何接口）  
8.     if ( FAILED(hrRet) )  
9.         delete pMsgbox;  
10.   
11.     return hrRet;  
12. }  

深入DllGetClassObject()

      现在让我们深入DllGetClassObject()内部。它的原型是：

[cpp]  view plain copy print ?

1. HRESULT DllGetClassObject( REFCLSID rclsid, REFIID riid, void** ppv );  

       rclsid是客户端所请求的组件对象类的CLSID。这个函数必须返回指定组件对象类的类工厂。这里的两个参数： riid 和 ppv 类似QI()的参数。不过在这个函数中，riid指的是COM库所请求的类工厂接口的IID。通常就是IID_IClassFactory。

因为DllGetClassObject()也创建一个新的COM对象（类工厂），所以代码与IClassFactory::CreateInstance()十分相似。开始也是进行一些有效性检查以及初始化。

[cpp]  view plain copy print ?

1. HRESULT DllGetClassObject ( REFCLSID rclsid, REFIID riid, void** ppv )  
2. {  
3.     // 检查客户端所要的CSimpleMsgBoxImpl类工厂  
4.     if ( !InlineIsEqualGUID ( rclsid, __uuidof(CSimpleMsgBoxImpl) ))  
5.         return CLASS_E_CLASSNOTAVAILABLE;  
6.   
7.     //检查指针ppv是不是void*类型  
8.     if ( IsBadWritePtr ( ppv, sizeof(void*) ))  
9.         return E_POINTER;  
10.   
11.     *ppv = NULL;  

      第一个if语句检查rclsid参数。我们的服务器只有一个组件对象类，所以rclsid必须是CSimpleMsgBoxImpl类的CLSID。__uuidof操作符获取先前在__declspec(uuid())声明中指定的CsimpleMsgBoxImpl类的GUID。下一步是创建一个类工厂对象。

[cpp]  view plain copy print ?

1. CSimpleMsgBoxClassFactory* pFactory;  
2.   
3.     // 构造一个新的类工厂对象  
4.     pFactory = new CSimpleMsgBoxClassFactory;  
5.   
6.     if ( NULL == pFactory )  
7.         return E_OUTOFMEMORY;  

     这里的处理与CreateInstance()中所做的有所不同。在CreateInstance()中是调用了QI()，并且如果调用失败，则删除COM对象。我们可以把自己假设成一个所创建的COM对象的客户端，调用AddRef()进行一次引用计数（COUNT = 1）。然后调用QI()。如果QI()调用成功，它将再一次用AddRef()进行引用计数（COUNT = 2）。如果QI()调用失败。引用计数将保持为原来的值（COUNT = 1）。在QI()调用之后，类工厂对象就使用完了，因此要调用Release()来释放它。如果QI()调用失败，这个对象将自我删除（因为引用计数将为零），所以最终结果是一样的。

[cpp]  view plain copy print ?

1. // 调用AddRef()增加一个类工厂引用计数，因为我们正在使用它  
2. pFactory->AddRef();  
3.   
4. HRESULT hrRet;  
5.   
6.     // 调用QI()查询客户端所要的类工厂接口  
7.     hrRet = pFactory->QueryInterface ( riid, ppv );  
8.       
9.     // 使用完类工厂后调用Release()释放它  
10.     pFactory->Release();  
11.   
12.     return hrRet;  
13. }  

再谈QueryInterface()

       前面讨论过QI()的实现，但还是有必要再看一看类工厂的QI()，因为它是一个很现实的例子，其中COM对象实现的不光是IUnknown。首先进行的是对ppv缓冲的有效性检查以及初始化。

[cpp]  view plain copy print ?

1. HRESULT CSimpleMsgBoxClassFactory::QueryInterface( REFIID riid, void** ppv )  
2. {  
3. HRESULT hrRet = S_OK;  
4.   
5.     //检查指针ppv是不是void*类型  
6.     if ( IsBadWritePtr ( ppv, sizeof(void*) ))  
7.         return E_POINTER;  
8.   
9.     //标准的QI初始化，将赋值为NULL.  
10.     *ppv = NULL;  

接下来检查riid，看看它是不是类工厂实现的接口之一：IUnknown 或 IclassFactory。

[cpp]  view plain copy print ?

1. // 如果客户端请求一个有效接口，则扶植给 *ppv.  
2. if ( InlineIsEqualGUID ( riid, IID_IUnknown ))  
3.     {  
4.     *ppv = (IUnknown*) this;  
5.     }  
6. else if ( InlineIsEqualGUID ( riid, IID_IClassFactory ))  
7.     {  
8.     *ppv = (IClassFactory*) this;  
9.     }  
10. else  
11.     {  
12.     hrRet = E_NOINTERFACE;  
13.     }  

最后，如果riid是有效接口，则调用接口的AddRef()，然后返回。

[cpp]  view plain copy print ?

1.     //如果返回有效接口指针，则调用AddRef()   
2.     if ( S_OK == hrRet )  
3.         {  
4.         ((IUnknown*) *ppv)->AddRef();  
5.         }  
6.   
7.     return hrRet;  
8. }  

ISimpleMsgBox实现

      最后的也是必不可少的一关是ISimpleMsgBox实现，我们的代码只实现ISimpleMsgBox的方法DoSimpleMsgBox()。首先用微软的扩展类_bstr_t将bsMessageText转换成TCHAR串。

[cpp]  view plain copy print ?

1. HRESULT CSimpleMsgBoxImpl::DoSimpleMsgBox ( HWND hwndParent, BSTR bsMessageText )  
2. {  
3. _bstr_t bsMsg = bsMessageText;  
4. LPCTSTR szMsg = (TCHAR*) bsMsg;   // 如果需要的话，用_bstr_t将串转换为ANSI   

做完转换的工作后，显示信息框，然后返回。

[cpp]  view plain copy print ?

1.     MessageBox ( hwndParent, szMsg, _T("Simple Message Box"), MB_OK );  
2.     return S_OK;  
3. }  

使用服务器的客户端

         我们已经完成了一个超级棒的COM服务器，如何使用它呢? 我们的接口一个定制接口，也就是说它只能被C或C++客户端使用。（如果在组件对象类中同时实现IDispatch接口，那我们几乎就可以在任何客户端环境中——Visual Basic，Windows Scripting Host，Web页面，PerlScript等使用COM对象。有关这方面的内容我们留待另外的文章讨论）。本文提供了一个使用ISimpleMsgBox的例子程序。这个程序基于用Win32应用程序向导建立的Hello World例子。文件菜单包含两个测试服务器的命令：如图所示：

 

Test MsgBox COM Server菜单命令创建CSimpleMsgBoxImpl对象并调用DoSimpleMsgBox()。因为这是个简单的方法，要写的代码不长。 我们先用CoCreateInstance()创建一个COM对象。

[cpp]  view plain copy print ?

1. void DoMsgBoxTest(HWND hMainWnd)  
2. {  
3.     ISimpleMsgBox* pIMsgBox;  
4.     HRESULT hr;  
5.   
6.     hr = CoCreateInstance ( __uuidof(CSimpleMsgBoxImpl),  // 组件对象类的CLSID  
7.                             NULL,                // 非聚合  
8.                             CLSCTX_INPROC_SERVER,  // 只使用进程内服务器  
9.                             __uuidof(ISimpleMsgBox), // 所请求接口的IID   
10.                            (void**) &pIMsgBox );   // 容纳接口指针的缓冲  
11.   
12.     if ( FAILED(hr) )  
13.         return;  
14.   
15.     // 然后调用DoSimpleMsgBox()方法并释放接口。  
16.     pIMsgBox->DoSimpleMsgBox ( hMainWnd, _bstr_t("Hello COM!") );  
17.     pIMsgBox->Release();  
18. }  

      就这么简单。代码中从头到尾都有TRACE语句，这样在调试器中运行测试程序就可以看到服务器的每一个方法是如何被调用的。另外一个菜单命令是调用CoFreeUnusedLibraries()函数，从中你能看到服务器DllCanUnloadNow()函数的运行。

其它细节——-COM宏

       COM代码中有些宏隐藏了实现细节，并允许在C和C++客户端使用相同的声明。本文中没有使用宏，但在例子代码中用到了这些宏，所以必须掌握它们的用法。下面是ISimpleMsgBox的声明：

[cpp]  view plain copy print ?

1. struct ISimpleMsgBox : public IUnknown  
2. {  
3.     // IUnknown 方法  
4.     STDMETHOD_(ULONG, AddRef)() PURE;  
5.     STDMETHOD_(ULONG, Release)() PURE;  
6.     STDMETHOD(QueryInterface)(REFIID riid, void** ppv) PURE;  
7.   
8.     // ISimpleMsgBox 方法  
9.     STDMETHOD(DoSimpleMsgBox)(HWND hwndParent, BSTR bsMessageText) PURE;  
10. };  

      STDMETHOD()包含 virtual 关键字，返回类型和调用规范。STDMETHOD_() 也一样，除非你指定不同的返回类型。PURE 扩展了C++的“=0”，使此函数成为一个纯虚拟函数。 STDMETHOD()和STDMETHOD_()有对应的宏用于方法实现——STDMETHODIMP和STDMETHODIMP_()。例如DoSimpleMsgBox()的实现：

[cpp]  view plain copy print ?

1. STDMETHODIMP CSimpleMsgBoxImpl::DoSimpleMsgBox ( HWND hwndParent, BSTR bsMessageText )  
2. {  
3.   ...  
4. }  

最后，标准的输出函数用STDAPI宏声明，如：

1.STDAPIDllRegisterServer()

       STDAPI包括返回类型和调用规范。要注意STDAPI不能和__declspec(dllexport)一起使用，因为STDAPI的扩展。输出必须使用.DEF文件。

服务器注册以及反注册

      前面讲过服务器实现了DllRegisterServer()和DllUnregisterServer()两个函数。它们的工作是创建和删除关于COM服务器的注册表入口。其代码都是对注册表的处理，所以在此不必赘言，只是列出DllRegisterServer()创建的注册表入口：键名 键值

[cpp]  view plain copy print ?

1. HKEY_CLASSES_ROOT   
2.   
3. CLSID   
4.   
5. {7D51904E-1645-4a8c-BDE0-0F4A44FC38C4}   
6. Default="SimpleMsgBox class"   
7. InProcServer32   
8. Default=[path to DLL]; ThreadingModel="Apartment"   

关于例子代码的注释

       本文的例子代码在一个WORKSPACE（工作间）文件中（SimpleComSvr.dsw）同时包含了服务器的源代码和测试服务器所用的客户端源代码。在VC的IDE环境中可以同时加载它们进行处理。在工作间的同级层次有两个工程都要用到的头文件，但每个工程都有自己的子目录。同级的公共头文件是：

1.ISimpleMsgBox.h——定义ISimpleMsgBox的头文件。

     SimpleMsgBoxComDef.h——包含__declspec(uuid())的声明。这些声明都在单独的文件中，因为客户端需要CSimpleMsgBoxImpl的GUID，不是它的定义。将GUID移到单独的文件中，使客户端在存取GUID时不依赖 CSimpleMsgBoxImpl的内部结构。它是接口，ISimpleMsgBox，对客户端很重要。

正如前面所说的，必须用.DEF文件来从服务器输出四个标准的输出函数。下面是例子工程的.DEF文件：

[cpp]  view plain copy print ?

1. EXPORTS  
2.     DllRegisterServer   PRIVATE  
3.     DllUnregisterServer PRIVATE  
4.     DllGetClassObject   PRIVATE  
5.     DllCanUnloadNow     PRIVATE  

每一行都包含函数名和PRIVATE关键字。这个关键字的意思是：此函数是输出函数，但不包含在输入库（import lib）中。也就是说客户端不能直接从代码中调用这个函数，即使是链接了输入库也不行。这个关键字时必须要用的，否则链接器会出错。

在服务器中设置断点链

如果你想在服务器代码中设置断点，有两种方法：第一种是将服务器工程(MsgBoxSvr)设置为活动工程，然后开始调试。MSVC将问你调试会话要运行的可执行程序。输入客户端测试程序的全路径，你必须事先建立好。第二种方法是将客户端工程(TestClient)设置为活动工程，配置工程的从属（dependencies）属性，以便服务器工程从属于客户端工程。这样如果你改变了服务器的代码，那么在编译客户端工程时会自动重新编译服务器工程代码。最后还要做的是当你开始调试客户端时必须告诉MSVC加载服务器符号（symbols）。下面是设置工程属性的对话框：Project->Dependencies菜单

 

为了加载服务器符号，打开TestClient的工程设置（Project->Settings菜单），选择Debug标签，并在Category组合框中选择Additional DLLs。在列表框中单击New一个入口，然后输入服务器DLL的全路径名。如下图所示：

 

这样设置以后，根据实际源代码的所在位置，DLL的路径将会做自动调整。

（第二部分完）