COM应用软件开发技术

韩冰

蔡倩

主题词： COM ActiveX C++ Builder

+ ~8 C8 Z5 j9 k, o5 A2 V" u

1.COM技术概述

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

% l5 X; A; [+ |: D% O/ X

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

◆用于创建ActiveX控件。

* z) ]6 z! u- D2 n/ M2 q

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

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

4 c. {7 o5 k5 o+ O. `2 m; O: w

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

' I6 P1 r) n. T2 N: @! E, d( m

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

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

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

5 W& }0 X4 V( f, U& N

2.建立COM服务程序

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

f6 n0 Q6 N7 g

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

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

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

8 H- ^( y5 D3 v3 E! {9 i

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

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

k9 t a% l0 p

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

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

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

7 J7 Q* g0 M9 [: p! {4 o; k* W

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

2.2建立COM接口对象

8 f" F+ N1 T9 g6 t

! y q0 F& }, g+ _9 U5 W+ G' a

; s6 |" x# b- }1 D0 P& b+ q

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

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

# _0 ?4 C. ~% i | b4 g1 n

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

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

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

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

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

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

' R" r* x3 q1 ^# W' z. G

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

- w) ^! R) k- h& L# G5 a* w5 Q. t- H' f

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

4 c+ q* A4 I8 C+ o/ F# F8 G5 W# o; }

[id(0x00000001)]

! D$ U& N% Z2 p: O: e) g4 v) _

# D0 L" Y$ G+ l& _. z; p: U

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

* D+ B4 m4 g0 C7 H

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

3 l9 I7 C6 z) P8 j

PCOMServer.TLB: 类型库文件；

" `2 W2 _1 H _ m1 t+ R

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

1 Q$ K, Z W6 r/ s; `& b

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

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

. q/ G) g2 U7 {5 D$ b

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

+ a5 a4 K% G- K) G6 Q( h

2.4 实现COM接口中的方法

+ o" ?( L \" e, o9 |

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

( D& P- z# \ B5 ~- J# f8 T, w

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

) ~4 E; p, w- G/ r' x! }1 q: b

{

*ret=x+y;

return S_OK;

7 T+ |5 g* T% K% P# y7 M) M

}

8 P i# `: T% z/ F, T

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

8 H) V9 C, n4 z* G( @. W/ x" d; U! N

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

. ?. [6 ~2 p* i% A I: w

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

, t8 D3 O! w' I

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

$ n6 d" g. t! f' y2 B, t. {+ j7 e1 K

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

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

2 V( E# X9 w! `) J

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

* O% n4 K n$ ]0 i# g

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

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

|( ~9 W- Z1 Y p( {3 L) c

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

3 P: m# R1 ~% k" a1 G9 Y- }7 L

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

3.建立COM客户程序

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

# g5 W* J3 } N

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

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

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

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

2 u4 E W" H5 r) |: w7 T; I

// Helpfile:

* z$ m3 N. [. a( r2 ?+ h) W r0 v

// DepndLst:

5 A# l, |/ F6 K7 {1 e

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

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

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

/ i8 D/ A) i' { |

#ifndef __PCOMServer_TLB_h__

6 j6 u) {/ t2 c! z: h. o

#define __PCOMServer_TLB_h__

' Y2 G0 p( M+ ?% V

#pragma option push -b -w-inl

#include <vcl/utilcls.h>

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

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

# s2 g# g& x* q* n' L: o, t, g

#endif

' V6 e& C" r2 ]* \ o' R

0 H5 T7 u4 | X, A( ]

#include <olectl.h>

1 w2 [/ ^5 F( Q/ ]9 a

#include <ocidl.h>

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

P, B* o5 w i8 x) N6 J

#if !defined(__TLB_NO_EVENT_WRAPPERS)

#include <atl/atlmod.h>

#endif

8 P$ \! W4 a, x( [% z4 Q9 [; q3 t

#endif

4 K. u# v! Q4 A: m# ^/ M

namespace Stdvcl {class IStrings; class IStringsDisp;}

`8 ~9 U- I; x8 x* d$ ]

using namespace Stdvcl;

$ S/ A( P1 }2 l4 _# E" U2 s

namespace Pcomserver_tlb

{

/ r9 u V, m: I8 y2 @6 d

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

4 ]" o2 O4 a! C$ U( A4 F

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

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' C5 y! X& J1 ^6 E) B

typedef IMyCOM MyCOM;

#define LIBID_OF_MyCOM (&LIBID_PCOMServer)

0 Y& ]( [9 H3 y) r& C8 G8 Y0 H- u

interface IMyCOM : public IDispatch

{

+ C4 g0 C) ?# R3 a) }2 C2 }

public:

8 y/ L; g( D0 z! \2 ~. E/ V

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

#if !defined(__TLB_NO_INTERFACE_WRAPPERS)

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

{

int ret;

$ Z- h3 P( z) b- m! m. N3 K9 L

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

# _3 w9 W1 m* }

return ret;

}

2 t/ ?! r3 A2 P. u9 z" W# b8 C3 I

#endif // __TLB_NO_INTERFACE_WRAPPERS

0 V" r, Q8 ^8 A* E4 D% D. i

};

#if !defined(__TLB_NO_INTERFACE_WRAPPERS)

0 V# ]+ a5 f2 ]7 P; s1 z

template <class T /* IMyCOM */ >

& [. t1 L% k0 {9 E; }- M2 N

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

{

, Y* D; J7 o* m9 u% G' \/ U3 K

public:

$ Q0 M v1 M% X) ]. T

TCOMIMyCOMT() {}

9 l& R! |7 @+ g# o& p0 E

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

4 k K4 V5 o& P' f$ N3 v6 {

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

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

& ]6 ~8 |1 n2 A5 @

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;

) G' {+ t' ]6 A

template<class T>

- O% ~+ a- a5 @; S1 D2 {

class IMyCOMDispT : public TAutoDriver<IMyCOM>

! F# @9 r% Y5 A8 L8 i

{

public:

' |0 c7 \# f3 Y8 O' A3 q9 H

IMyCOMDispT(){}

. w0 |8 G8 I) z( o4 I% Z

IMyCOMDispT(IMyCOM *pintf)

{

TAutoDriver<IMyCOM>::Bind(pintf);

}

IMyCOMDispT& operator=(IMyCOM *pintf)

6 J6 c0 Y* }5 s8 o1 ~2 M- m

{

TAutoDriver<IMyCOM>::Bind(pintf);

return *this;

}

7 F& G' X( Z( c! d3 F" P

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

" O4 p# P9 j4 y1 O+ V

{

return OLECHECK(Bind(CLSID_MyCOM));

}

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

+ Z5 y, P' g7 J! X$ I

{

return BindToActive(CLSID_MyCOM);

}

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

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

};

' |4 i) W7 Y* A) ]

typedef IMyCOMDispT<IMyCOM> IMyCOMDisp;

5 [6 G8 j) M4 l! ]& I6 u

template <class T> HRESULT __fastcall

7 w Y& @3 N9 i

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

{

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

}

4 I0 O2 k3 U; D, U. A+ v: t

template <class T> int __fastcall

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

1 A# c b, y0 y k4 J0 m

{

int ret;

* M5 i3 r! t. A$ G0 P8 n

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

$ {8 ^1 t: U# W8 F+ J' r3 C/ d% k/ Q

return ret;

/ B3 d1 F7 p: Z/ q/ ~; T

}

1 R& c2 v( ^( t1 e# k

template <class T> HRESULT __fastcall

. O# M: A a( n2 a3 R

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

: x& ~; M u- I" g1 n; l* Z

{

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

" X3 G- z! \3 ~" t

TAutoArgs<2> _args;

+ [' L! _/ V9 W4 I h0 R) I G

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

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

* L5 f% `+ [, x% \2 J0 e' X/ k

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

}

2 I1 }" U) h5 W# s6 B

template <class T> int __fastcall

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

3 g1 _1 `! S$ [% k" l

{

int ret;

( j! w3 z' x p8 L0 O9 E; l

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

7 C, H5 j' T# }9 m

return ret;

}

D! Y9 \6 N2 \- k

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

#endif // __TLB_NO_INTERFACE_WRAPPERS

}; // namespace Pcomserver_tlb

#if !defined(NO_IMPLICIT_NAMESPACE_USE)

) u1 E6 C }; D2 D

using namespace Pcomserver_tlb;

3 F7 A! Q; }8 M0 C0 w3 e

#endif

- N, ?6 w5 d: ^; E( Z- k

#pragma option pop

; Y7 Q* M q3 e1 V- D! S( z

#endif // __PCOMServer_TLB_h__

) w% S" N) e2 }. _7 e+ {0 x' R

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

# ^5 |2 D( U" I* `8 m

interface IMyCOM : public IDispatch

: N" s1 [4 ]3 ] P/ f1 w1 _

class TCOMIMyCOMT : public TComInterface<IMyCOM>

5 r8 B) ?; o8 S* }' h, Z

class IMyCOMDispT : public TAutoDriver<IMyCOM>

class CoMyCOM： public CoClassCreator

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

. v2 ~) k+ q( k; I$ r- T

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

0 ]' S) y7 {' u- \: B

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

1 Z; W: r( ]8 i* n

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

! ^: R2 f: h7 V# f

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

8 k- c& R$ b {2 V+ `6 Y

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

8 ]2 _8 W! W- {* y" y% l

int x=6,y=6;

TCOMIMyCOM O;

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

: u( P0 v$ w5 i# ^' X3 _! c8 S

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

Edit1->Text=IntToStr(y);

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

; _- ]# Z0 v: ^. l+ c1 Y6 Y

int x=6,y=6;

1 V; g5 \) F' x) F7 S* T( U6 l

IMyCOMDisp app;

% G5 U x' \- h# l0 T

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

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

Edit1->Text=IntToStr(y);

! \( `3 X* |- O6 q, H( v

4.小结

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

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

% e! |* n$ U1 l