COM应用软件开发技术

韩冰

蔡倩

: q/ ^6 v! I% t% b" j: X v

主题词： COM ActiveX C++ Builder

1.COM技术概述

7 x3 k; @! A/ `1 I# Y# Y3 a% D

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

4 O; h: u" p. x5 m4 H

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

◆用于创建ActiveX控件。

8 v- b5 c* \' Z, X* w7 S

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

8 x6 k+ W) A1 ^# f

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

$ O8 r/ a3 _& Q4 c5 U

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

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

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

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

F/ p' h5 \" D* T3 O

2.建立COM服务程序

2 n& U! c% Y4 g" C1 ~: y3 ?# @

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

0 j: U+ s- D1 B3 T6 L& s4 b) k

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

$ [: {4 `* z$ n- @% Z t* \& E/ @

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

3 p* y/ P$ d. o+ s" O

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

" H& C% [- ?' K2 J& ~2 i4 c# ^, \

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

" P9 W& O: O. u4 `2 g6 `. K2 O

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

0 i W0 P5 X! ]

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

, ^, h( y+ ?5 s- R2 ~8 y( j3 ?2 r9 A

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

) z1 X/ m$ P8 B- [: `) i8 ]6 k

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

) D2 J4 H7 |5 O

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

$ [8 W0 E {8 W% B# p! ?

2.2建立COM接口对象

/ d4 f8 H+ G8 b( ]$ k

6 ?8 I) j/ Y( l8 G

( m, Y, F7 m3 F2 N# T6 [

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

1 T3 w& x$ k! p9 J; C+ D# a

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

7 T9 b i4 y- B9 H( O+ H) F* x

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

& ?0 `$ `2 m* P. {# p- u: w7 D( f

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

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

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

( h* `. X4 z7 _9 Z& f

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

8 a" T |0 o# [& u

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

6 x% S2 I7 v; `, w0 x0 Y' x6 S& z

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

( d- l7 R9 s4 L, v: [) h

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

[id(0x00000001)]

0 [* Z; U/ E9 `2 R, ?5 M" t

. `7 g* \$ J+ I, r- N' s$ U

8 b5 _( \. ]) i( S. O

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

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

) |: b7 n7 ^3 O6 \( s

PCOMServer.TLB: 类型库文件；

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

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

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

- b% J6 c$ M/ i6 v

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

* A& a3 ? R7 z* E r5 l

2.4 实现COM接口中的方法

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

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

{

*ret=x+y;

9 [3 q C1 O. O+ A

return S_OK;

}

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

5 m B( x T* Y# U3 T$ [

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

' e6 s3 v! ]/ ?# K; I

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

# j+ p% C q1 t L" R1 [6 l/ _- r

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

) w: O) Q8 z! e4 B! d3 w

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

- @+ Z( _0 R" k4 [; J' \) U

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

2 q$ y7 f$ U' u2 Q+ e" M p+ P

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

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

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

8 M% G& F9 S# b/ B& K2 N

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

) v( M; F6 {4 u/ @, G+ d

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

3.建立COM客户程序

' V! o8 G: {. f% z

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

5 m2 t5 s2 Y* N# f$ j

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

; c% ^) ` D9 _! d0 | b

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

8 w9 e& `0 ^' t% L

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

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

// Helpfile:

* O& K& n* F& Y+ p& e m5 U( C

// DepndLst:

. B! J% [! c7 R$ {8 ]% i0 X

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

R0 [& n9 n/ S' [4 D' X

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

5 J+ Y+ ^9 s/ P0 B

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

#ifndef __PCOMServer_TLB_h__

#define __PCOMServer_TLB_h__

/ t4 Q& _2 } o3 P! N

#pragma option push -b -w-inl

#include <vcl/utilcls.h>

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

! e$ N* ]" _* ]% {

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

#endif

, k E' }. ?( u* `4 L* g5 \

#include <olectl.h>

#include <ocidl.h>

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

#if !defined(__TLB_NO_EVENT_WRAPPERS)

V4 ~- Q3 ~. @4 Q4 D/ S8 X4 ~4 {

#include <atl/atlmod.h>

#endif

#endif

) c' g5 g: \4 L O5 y. \5 `

namespace Stdvcl {class IStrings; class IStringsDisp;}

/ s# a$ j2 r1 W' R" b

using namespace Stdvcl;

1 y7 s& N7 B) T$ S

* l, M3 l- v% ~4 @. s4 D

namespace Pcomserver_tlb

{

+ N; |' B9 Y& x6 [6 `7 g

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

* ~% ~6 [& D7 }" i" j

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

$ ^+ o0 l0 \" g, Z0 k

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

; V9 ?5 w( `0 i% R. S

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

typedef IMyCOM MyCOM;

/ R) A6 Q1 O3 U7 p! G

#define LIBID_OF_MyCOM (&LIBID_PCOMServer)

interface IMyCOM : public IDispatch

. L" h- B+ p. H- L J2 v

{

public:

: O3 |( l% n9 B/ a7 K. ^

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

& i3 N# T3 _( S; H* w: o( `

#if !defined(__TLB_NO_INTERFACE_WRAPPERS)

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

{

int ret;

" [/ [2 E/ V* W7 X; `

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

% y# `4 ~ l7 B1 ^% [

return ret;

}

#endif // __TLB_NO_INTERFACE_WRAPPERS

4 X& r% R$ t8 r

};

$ P- @ F3 `4 V4 U5 A

#if !defined(__TLB_NO_INTERFACE_WRAPPERS)

$ @7 D% c1 c6 ? i# b! @ ?1 {

template <class T /* IMyCOM */ >

4 D' ^% q; u1 K+ S& T3 H" M

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

, v @# z+ P. k7 B" f

{

public:

# r9 E8 P* U; y2 O& ~

TCOMIMyCOMT() {}

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

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

7 z7 k8 w8 m$ e

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

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

' L- e! W! @7 o2 U+ j

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

};

* M1 Y2 S" @1 q- P

typedef TCOMIMyCOMT<IMyCOM> TCOMIMyCOM;

* s5 @$ W4 ?1 I

0 R7 ~ q" {+ p4 x+ A1 h9 t

template<class T>

class IMyCOMDispT : public TAutoDriver<IMyCOM>

{

# z1 B" b+ j9 u! m

public:

IMyCOMDispT(){}

IMyCOMDispT(IMyCOM *pintf)

. r) B) |- r6 [( O7 w

{

TAutoDriver<IMyCOM>::Bind(pintf);

}

IMyCOMDispT& operator=(IMyCOM *pintf)

{

# }9 N7 o' X1 B4 |: p6 ^

TAutoDriver<IMyCOM>::Bind(pintf);

return *this;

% z" B j3 H$ L9 b6 C3 Z% E

}

; @' p2 ~ u- o9 I ~" T3 @' L2 h# R

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

e8 \/ e% s5 ^8 X

{

return OLECHECK(Bind(CLSID_MyCOM));

}

; z! x. ?1 J: a6 t8 @& F3 M. ~7 O

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

8 r* q* U1 S' P0 Z8 x% q

{

return BindToActive(CLSID_MyCOM);

" L7 l5 u: z n

}

) }0 G% l; F. a! K

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

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

5 H7 L3 i- e g1 N, l

};

typedef IMyCOMDispT<IMyCOM> IMyCOMDisp;

' y; X+ |1 x( X" E

template <class T> HRESULT __fastcall

1 x; }: a4 k+ v" O

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

{

, U% {2 f) i* G9 U6 w; I

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

}

* C; W6 j5 T8 G" S

+ ^& M" ]1 e% [; ]3 w7 B

template <class T> int __fastcall

+ L9 H2 p" y: a# l3 X

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

3 @6 Z7 l( X* H" s

{

int ret;

- q9 M. V3 G% X) W; ~0 S

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

; E: r* d+ B6 i* C

return ret;

# L2 K! z, {2 h& f( |

}

template <class T> HRESULT __fastcall

9 L" e9 a0 @7 n9 C6 A, F

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

{

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

+ s( q* C# z4 J+ B) j. v

TAutoArgs<2> _args;

- r/ c! T/ m2 W9 I' o, y0 Z V0 m

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

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

8 |- p5 c2 E3 J* u% \1 j! Q( C& C5 P

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

}

template <class T> int __fastcall

0 r x* R/ l" M3 C% }9 t9 r1 J

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

{

int ret;

( y& D$ O! h" P, K/ J5 v

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

2 W: j+ D2 @! h! f

return ret;

}

7 r2 o) r: s4 d0 e2 B

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

#endif // __TLB_NO_INTERFACE_WRAPPERS

2 x. Q) `/ t @5 l

}; // namespace Pcomserver_tlb

#if !defined(NO_IMPLICIT_NAMESPACE_USE)

using namespace Pcomserver_tlb;

9 `8 n' i0 Z2 H1 b( `

#endif

#pragma option pop

2 B7 T- N2 K0 ]/ m" B

#endif // __PCOMServer_TLB_h__

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

# N! ^( K" y3 A. N

interface IMyCOM : public IDispatch

8 i3 b, V8 b7 R, P5 B

class TCOMIMyCOMT : public TComInterface<IMyCOM>

class IMyCOMDispT : public TAutoDriver<IMyCOM>

class CoMyCOM： public CoClassCreator

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

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

$ d7 R* C2 U5 b- \* `4 d1 B7 N& Y

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

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

# _+ c+ X6 i, _/ ]

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

% p1 j7 O2 R' l5 {5 e& h C* L

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

# Z3 F5 d8 N/ {& x& |+ X9 d

int x=6,y=6;

TCOMIMyCOM O;

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

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

- f! I$ S. U2 T% g

Edit1->Text=IntToStr(y);

) K0 q) k6 Y9 V% H

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

& p& ^! ^, E4 R8 `

int x=6,y=6;

) p+ X, M8 \2 q r- t

IMyCOMDisp app;

3 [& h% w `+ X9 m& H; C) U' U

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

" c& Y0 K+ a. O' _; z% y

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

7 f6 E4 Q+ J& e' ^, @2 ?2 C$ i

Edit1->Text=IntToStr(y);

+ U8 L; M6 F- Q' g

4.小结

" ]& q# o, D$ `7 h# b

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

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

7 L+ W) Q6 P1 X- p! H) H0 H- R1 w

! @7 }# b; Y) L