COM应用软件开发技术

韩冰

蔡倩

主题词： COM ActiveX C++ Builder

+ g- }3 V! Z" k9 E! M' y

1.COM技术概述

7 H; I. c; x, ?; T

COM表示Component Object Model(组件对象模型)，它是Microsoft大力推广的软件开发技术。采用COM规范开发的应用软件具有强大的功能，主要有如下几点：

% s3 A( q" ~* D+ s* X* n

◆COM是二进制编程规范，可以编写被多种语言使用的代码。

: Y, y0 _$ X# M2 ?/ [ H- Y0 H0 s4 c

◆用于创建ActiveX控件。

◆通过OLE Automation 控制其它的程序。

) x9 Y5 c+ Z; e* W3 l2 v2 n5 @2 [8 K

◆与其它机器上的对象或程序进行对话，构成分布式应用程序。

Microsoft推出Windows 98和Windows NT 5.0后，整个操作系统的核心都围绕着COM来建立。我们可以把Windows系统看作是一系列的COM接口，在需要是可以调用这些接口。如DirectX就是一系列的COM接口服务程序，通过它可以进行高性能的Windows图形程序设计。

用COM技术开发的应用程序从理论上说是客户/服务器模式的程序。程序员可以使用一系列的COM服务程序来构造他们自己的应用程序，这些服务程序可以根据需要随时嵌入到主程序中。在分布式系统中，可以通过网络来访问这些服务程序。将来，操作系统和整个网络可能会被看作是一套以COM对象形式提供的服务集。一部分程序员负责建立这些服务，而另一部分程序员只负责如何调用它们。其目的是实现软件的即插即用。

) Q. w9 n' W1 j* W( Y3 g

开发COM应用程序是比较复杂的，通常需采用ActiveX模板库（ATL）来编程。在这里我们推荐采用C++ Builder来开发COM程序，Inprise（Borland）公司的面向对象技术一直处于世界领先水平，C++ Builder采用可视化方法，隐藏了ATL的实现细节，自动生成COM接口所需的代码。

1 `5 F0 a# \6 e5 X. y7 Q

以下的程序举例采用C++ Builder 4.0 编制,在中文Windows98环境下运行。

8 S3 Y7 Z. M. X* P9 t. P

2.建立COM服务程序

; n% W% ?% X8 O! r5 x

COM服务程序有三种形式，第一种是驻留在本地机器上以DLL形式提供，该服务程序被调用时，嵌入到调用程序的线程中运行；第二种是驻留在本地机器上以EXE形式提供，该服务程序被调用时将占用独立的线程运行；第三种驻留在远端机器上以EXE形式提供，服务程序通过网络被调用，它在远端机器上运行，结果通过网络返回调用者。

在此采用第一种形式建立COM服务程序，这也是最常用的形式，DirectX就是采用这种形式提供的。

, |% v, O* @9 ]9 P

C++ Builder建立COM服务程序的方法如下：

2.1创建支持COM接口对象的动态连接库文件：

◆打开File/New/ActiveX项目页，选择ActiveX Library；

O0 `; ]9 h3 q, z: ]# w% n4 I4 P

◆选择Save All 将项目以PCOMServer文件名保存；此时C++ Builder 自动生成如下的文件：

0 n2 y6 F' B; H* r( L7 J) B. V

PCOMServer.bpr：工程的项目文件；

PCOMServer.h,PCOMServer.cpp：支持COM对象的动态连接库源文件，其中有许多函数用于COM接口对象的自动装配，大家不用去编辑它们；

) V' V& T3 A7 I# T) J1 f* o

PCOMServer_ATL.h,PCOMServer_ATL.cpp：ATL形式的文件供C++ Builder编译器调用，大家也不要去编辑它们。

◆打开Project/Options/Linker 属性页不选中Use dynamic RTL选项，打开Project/Options/Packages属性页不选中Builder with runtime packages选项，这两步操作可以使开发的COM动态连接库不依赖C++ Builder的VCL动态连接库，有利于独立发行，但在一般情况下还是建议选中这两项。

7 G8 k s6 [6 }

2.2建立COM接口对象

, ~, m. }; r4 E2 O

打开File/New/ActiveX属性页,选择Automation Object表示向服务程序中插入一个自动类型的COM对象，我们选择这种类型的COM对象是为了可以自动注册，并且自动支持可以被其他语言调用。此时出现如下的对话框，输入COM类的名字MyCOM即可，对话框中的其它选项用于规定COM对象的性质，可查看帮助信息。

2.3通过类型库编辑器编辑COM对象中相应接口对象的属性和方法

4 N/ P, |' _6 I

此时自动进入类型库编辑器，类型库用于存储COM对象的说明，是一个可以被多种语言调用的头文件包。在类型库中，可以定义COM对象的接口，定义接口对象的属性和方法等。类型库编辑器如下所示：

可以看出此时自动产生了MyCOM类的一个接口类IMyCOM，在COM应用软件中我们实际上是与接口对象打交道，下面通过类型库编辑器为IMyCOM接口定义方法和属性。

- _& q/ G, V: r- h. y1 L3 a

◆单击编辑器顶部的Method按钮；

◆在Arributes页面的Name字段中输入方法的名称，本例中是AddInt用于整数加法；

◆在Parameters页面中，单击Add按钮编辑方法中的参数；

x和y是输入的两个整数，ret用于返回运算的结果，必须定义为指针型

◆切换到Flags页面，可以对接口的属性作调整；

◆在Text页面中可以检查生成的IDL代码：

5 |' c, l" J" X/ Y [' Y

[id(0x00000001)]

3 z& O/ ~+ p1 D% P" E+ U7 {1 s- W

5 U1 ^# O" L; o0 V% ~. Y; u, |! Q2 U

HRESULT _stdcall AddInt([in] int x, [in] int y, [out, retval] int * ret );

◆单击Refresh按钮，此时可以关闭类型库编辑器。当需要为接口添加新的属性和方法时，可以通过View/Type Library重新打开编辑器。选择Save All用C++ Builder提供的缺省文件名保存类型库的相关文件如下：

. G$ {. c. w: W2 J4 j0 @% C+ ?) L

PCOMServer.TLB: 类型库文件；

: o* T+ ]$ n( v& L; n

PCOMServer_TLB.cpp:包含COM接口和对象的说明，其主要目的是方便访问，在客户程序中需将本文件包含到客户程序的工程中；

7 T) Q8 `+ K Z9 f

PCOMServer_TLB.h: PCOMServer_TLB.cpp的头文件，通过#include引入到客户程序中。

1 [7 w/ V* ~3 a, E

MyCOMImpl.cpp: 该文件是我们需要编写程序代码的地方，实现类型库定义的接口对象的方法和属性；

L3 P4 q) |+ Z: C8 a

MyCOMImpl.h: MyCOMImpl.cpp的头文件。

2.4 实现COM接口中的方法

4 B1 H1 T/ Y4 B, o1 @( b" Q4 W

打开MyCOMImpl.cpp文件会发现我们在类型库编辑器中定义的方法，为该方法编写代码如下：

8 f* d+ R, S) p0 K

STDMETHODIMP TMyCOMImpl::AddInt(int x, int y, int* ret)

{

5 c, @$ I7 J0 v. `# O

*ret=x+y;

5 ]( }0 K7 G) ]- B( q, G, A

return S_OK;

}

; } a8 ^! B- J d, p

2.5 生成DLL文件并注册COM对象

◆选择Project/Builder PCOMServer 生成PCOMServer.DLL文件。

) i- _: O2 Q, w4 i

◆打开类型库编辑器，单击Register按钮完成对COM对象的注册。

5 {/ c$ V4 F+ h" c. E ]

通过Windows任务栏中的Run菜单运行REGEDIT程序，在Windows注册表的HKEY_CLASSES_ROOT键下查找到PCOMServer.MyCOM子键,PCOMServer为DLL文件的名字,MyCOM为COM对象的名字,在下面可以看到该COM对象的全局唯一描述符CLSID如下:

% W. {$ t7 N8 O) q* _0 g3 Z

{59834F03-49F1-11D3-B85B-00E09804A418}

注意:不同的机器生成的描述符不同.

在HKEY_CLASSES_ROOT键下查找到CLSID子键，在它下面找{59834F03-49F1-11D3-B85B-00E09804A418}子键，下面有如下的条目：

( L* R7 f! i& ?/ r& @- ]* F: O6 x5 w

InprocServer32：存储PCOMServer.DLL的路径目录；

ProgID：存储COM对象的注册名：PCOMServer.MyCOM；

+ o0 D g4 {+ t' m: J

Typelib：存储COM对象的CLSID值{59834F03-49F1-11D3-B85B-00E09804A418}。

; s" M P. `4 a/ a1 [

COM对象就是通过在注册表中的纪录实现DLL与客户程序的自动连接。

$ V3 Z( h7 v& ^7 R: X/ a/ F3 _

3.建立COM客户程序

0 b6 d+ V& {' L8 k5 r( N4 r

客户程序将访问PCOMServer.DLL服务程序中的MyCOM对象，这些对象的说明保存在前面所述的TLB文件中。我们可以直接将PCOMServer_TLB.cpp加入到客户程序的项目文件中，并在客户程序中引用PCOMServer_TLB.h文件；也可以通过Project/Import Type Library引用PCOMServer_TLB.TLB文件，重新生成.cpp和.h文件,自动完成上述过程。

客户程序的编程重点是实现对服务程序中COM对象的方法的调用，调用的方法有多种，都是通过所谓的代理接口来完成的，这些代理接口在PCOMServer_TLB.h中有详细的定义，从这些定义中可以看出这些代理接口调用对象方法的过程。

5 p J3 x% p( S* Z$ D

PCOMServer_TLB.h文件很重要，包含了调用MyCOM对象的各种接口信息，该文件主要内容如下：

// Type Lib: D:\CAI\com\PCOMServer.tlb

* e0 p c7 s, Q3 B- N

// IID\LCID: {5BD378E5-4B57-11D3-B85B-00E09804A418}\0

! m9 X! t( Z- e( o" \

// Helpfile:

// DepndLst:

// (1) v2.0 stdole, (C:\WINDOWS\SYSTEM\STDOLE2.TLB)

3 D$ ?: g$ K, h" D+ ~9 B& q

// (2) v4.0 StdVCL, (C:\WINDOWS\SYSTEM\STDVCL40.DLL)

// ************************************************************************

+ j0 A) ?2 r" X6 K- s

#ifndef __PCOMServer_TLB_h__

" E2 I8 C6 ` t: l& c [2 z0 K

#define __PCOMServer_TLB_h__

5 }4 Y" H3 q0 X3 e- r' q" @, a

#pragma option push -b -w-inl

#include <vcl/utilcls.h>

#if !defined(__UTILCLS_H_VERSION) || (__UTILCLS_H_VERSION < 0x0101)

8 ^& L3 j7 N) T

#error "This file requires an newer version of the header file UTILCLS.H"

#endif

* R+ d' t. W0 L N: O. |

#include <olectl.h>

/ ]/ Q$ E; p( X% }

#include <ocidl.h>

#if defined(USING_ATLVCL) || defined(USING_ATL)

/ w8 O7 d$ P* R- ]9 e' y0 `( A0 V

#if !defined(__TLB_NO_EVENT_WRAPPERS)

#include <atl/atlmod.h>

#endif

* S5 j, h! L# n5 f9 H& d; b6 Y

#endif

% l8 G& A! ?2 i: M

namespace Stdvcl {class IStrings; class IStringsDisp;}

. L' h0 C" x. a O- Q4 ^

using namespace Stdvcl;

namespace Pcomserver_tlb

! Y& d b8 z, Q- F9 t# C

{

DEFINE_GUID(LIBID_PCOMServer, 0x5BD378E5, 0x4B57, 0x11D3, 0xB8, 0x5B, 0x00, 0xE0, 0x98, 0x04, 0xA4, 0x18);

DEFINE_GUID(IID_IMyCOM, 0x5BD378E6, 0x4B57, 0x11D3, 0xB8, 0x5B, 0x00, 0xE0, 0x98, 0x04, 0xA4, 0x18);

% h. `; o1 F0 h. ]( H

DEFINE_GUID(CLSID_MyCOM, 0x5BD378E8, 0x4B57, 0x11D3, 0xB8, 0x5B, 0x00, 0xE0, 0x98, 0x04, 0xA4, 0x18);

interface DECLSPEC_UUID("{5BD378E6-4B57-11D3-B85B-00E09804A418}") IMyCOM;

" A& _3 z3 ~. {4 `. [; X, \

typedef IMyCOM MyCOM;

' c6 R4 p" j2 N! ~! i

#define LIBID_OF_MyCOM (&LIBID_PCOMServer)

; @# t2 G) X$ L: \

interface IMyCOM : public IDispatch

0 ~, ~1 w0 O" U2 w* z/ a3 v

{

public:

virtual HRESULT STDMETHODCALLTYPE AddInt(int x/*[in]*/, int y/*[in]*/, int* ret/*[out,retval]*/) = 0; // [1]

. d3 v6 N% x4 `. o; P' c) v. T9 ^

#if !defined(__TLB_NO_INTERFACE_WRAPPERS)

3 a/ ?; h5 B1 L# s$ }/ N h3 J

int __fastcall AddInt(int x/*[in]*/, int y/*[in]*/)

+ L1 q3 H+ Q7 G# G/ x- {; y7 V/ _

{

$ m6 ^0 E4 ^7 ^! \9 i, _% E

int ret;

OLECHECK(this->AddInt(x, y, &ret));

return ret;

7 r2 X) o8 x5 z& m2 R, z

}

0 h/ J& a' U5 \9 q

#endif // __TLB_NO_INTERFACE_WRAPPERS

1 t9 a7 `# A, C- c0 {1 b& M& P

};

% j/ A6 f) @' t' f& |5 z* v2 S

#if !defined(__TLB_NO_INTERFACE_WRAPPERS)

: H# o. t+ {* w) l/ l

template <class T /* IMyCOM */ >

+ `# I9 _& k- M+ }

' v# t- P/ x6 M; g* u

class TCOMIMyCOMT : public TComInterface<IMyCOM>, public TComInterfaceBase<IUnknown>

9 i8 w9 ^% _, n* G

{

public:

0 `7 J- R' m, s; v

TCOMIMyCOMT() {}

9 J; g9 m4 n8 n. F V

TCOMIMyCOMT(IMyCOM *intf, bool addRef = false) : TComInterface<IMyCOM>(intf, addRef) {}

TCOMIMyCOMT(const TCOMIMyCOMT& src) : TComInterface<IMyCOM>(src) {}

# q- D; x7 r. F( e

TCOMIMyCOMT& operator=(const TCOMIMyCOMT& src) { Bind(src, true); return *this;}

HRESULT __fastcall AddInt(int x/*[in]*/, int y/*[in]*/, int* ret/*[out,retval]*/);

int __fastcall AddInt(int x/*[in]*/, int y/*[in]*/);

};

typedef TCOMIMyCOMT<IMyCOM> TCOMIMyCOM;

8 A, D: p4 H0 I1 u+ m

template<class T>

class IMyCOMDispT : public TAutoDriver<IMyCOM>

{

public:

" H% p" A1 Y9 d# D& Z: U, g

IMyCOMDispT(){}

0 P5 o% `: r) f! M! x

IMyCOMDispT(IMyCOM *pintf)

{

TAutoDriver<IMyCOM>::Bind(pintf);

}

IMyCOMDispT& operator=(IMyCOM *pintf)

' l6 V: u9 O) [' m6 W

{

TAutoDriver<IMyCOM>::Bind(pintf);

return *this;

- [8 ?+ a; u9 j5 X; [) J8 {9 i

}

7 p; R3 [6 H( y, r9 I

HRESULT BindDefault(/*Binds to new instance of CoClass MyCOM*/)

{

return OLECHECK(Bind(CLSID_MyCOM));

}

3 d; ^& F4 C7 p: t7 M- M" s

HRESULT BindRunning(/*Binds to a running instance of CoClass MyCOM*/)

9 g5 ]% X( Z0 {9 a$ e

{

; W# r! c2 }! X3 ?

return BindToActive(CLSID_MyCOM);

) d5 V: X9 C& J. S4 u

}

7 o* S0 ?. M. B

HRESULT __fastcall AddInt(int x/*[in]*/, int y/*[in]*/, int* ret/*[out,retval]*/);

int __fastcall AddInt(int x/*[in]*/, int y/*[in]*/);

3 t6 u( y5 b' M B7 ~

};

7 t/ E4 y7 ]4 p

typedef IMyCOMDispT<IMyCOM> IMyCOMDisp;

" M9 R& b* j& Q8 f+ V" G$ u9 i

m' Z0 @1 J6 G& H V3 @" ~. Z8 k/ ]: L

template <class T> HRESULT __fastcall

TCOMIMyCOMT<T>::AddInt(int x/*[in]*/, int y/*[in]*/, int* ret/*[out,retval]*/)

{

return (*this)->AddInt(x, y, ret);

6 S: N3 h/ M& O8 F3 g

}

8 S1 e, E& \; B o9 Y9 p7 @

" _' x1 v: e* M9 i

template <class T> int __fastcall

5 N) k# q9 o: W$ ^; ^7 M

TCOMIMyCOMT<T>::AddInt(int x/*[in]*/, int y/*[in]*/)

) d$ i* }* R8 z' a# S8 ^9 z* l

{

0 c) C' ]0 T2 ^. Z3 M

int ret;

" r+ g9 }4 i8 e7 g& _8 ?

OLECHECK(this->AddInt(x, y, &ret));

$ a" W% O, }: k4 A0 ^

return ret;

4 S% A1 T% L2 C* d, T

}

! v3 _+ q, d) J! K0 X

template <class T> HRESULT __fastcall

- ~+ b4 [! H6 ~

IMyCOMDispT<T>::AddInt(int x/*[in]*/, int y/*[in]*/, int* ret/*[out,retval]*/)

' y( s1 N- Q7 V+ Q4 A4 _/ |8 `

{

static _TDispID _dispid(*this, OLETEXT("AddInt"), DISPID(1));

' C( L" ]6 n( P/ l0 m

TAutoArgs<2> _args;

_args[1] = x /*[VT_INT:0]*/;

_args[2] = y /*[VT_INT:0]*/;

6 N1 M$ E2 w- _4 z( t0 U

return OutRetValSetterPtr(ret /*[VT_INT:1]*/, _args, OleFunction(_dispid, _args));

}

" k6 i- }! R& o. x% r) a+ C

template <class T> int __fastcall

IMyCOMDispT<T>::AddInt(int x/*[in]*/, int y/*[in]*/)

+ }9 R6 k1 f8 p `$ H

{

int ret;

this->AddInt(x, y, &ret);

0 [4 y4 J5 ~ }: ]0 [- \! @

return ret;

}

+ s v$ ^& s+ K4 k$ L6 A

typedef TCoClassCreatorT<TCOMIMyCOM, IMyCOM, &CLSID_MyCOM, &IID_IMyCOM> CoMyCOM;

#endif // __TLB_NO_INTERFACE_WRAPPERS

}; // namespace Pcomserver_tlb

#if !defined(NO_IMPLICIT_NAMESPACE_USE)

using namespace Pcomserver_tlb;

#endif

#pragma option pop

#endif // __PCOMServer_TLB_h__

o2 Z) J; ]. }; h0 r. A' u+ y

下面是文件中说明的主要对象及其定义：

9 d8 W0 @' P: G9 e8 [" P

interface IMyCOM : public IDispatch

' c* W: r' U+ O) w9 L. s) P

class TCOMIMyCOMT : public TComInterface<IMyCOM>

class IMyCOMDispT : public TAutoDriver<IMyCOM>

class CoMyCOM： public CoClassCreator

1 B' U% V$ Y) j+ l

◆IMyCOM：通过IDispatch接口来调用对象的方法，该接口可以使对象被不支持虚拟函数表(VTable)的语言(如Visual Basic)说调用。这是一种很慢很苯的接口调用方式。

9 i! h6 J; h2 Z2 S- D

◆TCOMIMyCOMT：通过所谓的智能接口来调用对象的方法，既可以实现IDispatch调用，也可以采用VTable进行调用，从而实现最快的调用速度。

: n8 Y4 {+ g, O

◆IMyCOMDispT：通过disp接口来调用对象的方法，可以提高Idispatch接口的访问速度，但还是比不上VTable接口。

◆CoMyCOM：通过使用CoClassCreator可以自动产生TCOMIMyCOM代理的实例。

下面介绍一下实现智能接口和Disp接口调用的客户程序。这个客户程序很简单，有两个按钮分别完成两种接口调用的方法，一个编辑框显示结果。

◆智能接口的VTable调用方法如下：

7 g6 M" F T9 g6 ^2 K, `7 x) N

int x=6,y=6;

* I8 k& A, A2 D! y6 `; R! J

TCOMIMyCOM O;

O=CoMyCOM::Create(); //通过CoClassCreator完成初始化

O->AddInt(x,y,&y); //Vtable形式调用

+ f) a7 v8 P$ B1 ^9 A3 g8 t

Edit1->Text=IntToStr(y);

◆DISP接口的调用方法如下：

int x=6,y=6;

+ U$ l( C, H: w; K s

IMyCOMDisp app;

" r. m+ @" l( c& V

app.BindDefault(); //通过Bind完成初始化

0 S8 Q6 r& ]" m% G$ S

app.AddInt(x,y,&y); //Disp形式调用

) `4 L* A/ m1 o

Edit1->Text=IntToStr(y);

# o. V6 R6 Q/ m7 A% b' Q

4.小结

% \! P+ |8 F3 T5 w

上面的程序举例是很简单的，但却详细说明了COM应用软件的开发过程。COM技术不是一个编程语言，而是一种编程规范和方法。采用COM技术可以开发功能强大的软件，有利于分布式应用技术的实现，有利于多人合作开发，也可以帮助我们理解Windows系统本身。COM的接口技术是比较复杂的，想进一步了解COM技术可参阅清华大学出版社的《COM技术内幕》一书。

2 d: y1 h8 R; y3 V+ ?

C++ Builder是开发COM应用软件的好工具，它隐含了COM实现的细节，我们只需与它打交道就可以开发完善和强大的COM应用程序。希望有更多的人转到COM应用软件的开发上来，COM技术是软件技术未来的发展方向，是实现软件工程中软件即插即用的有效途径。