|
蔡倩
# `2 X5 ^& x$ T( }+ B$ ~主题词: COM ActiveX C++ Builder
7 q: j/ r( j( m b6 P1.COM技术概述 , c3 \5 R" F. g, I! n0 Q: P
COM表示Component Object Model(组件对象模型),它是Microsoft大力推广的软件开发技术。采用COM规范开发的应用软件具有强大的功能,主要有如下几点:
+ C+ j. e" r% k7 X5 A# v◆COM是二进制编程规范,可以编写被多种语言使用的代码。
9 x M: M6 O% a+ q0 G3 Y4 }: Z◆用于创建ActiveX控件。
: f# v& t# X z# u% `◆通过OLE Automation 控制其它的程序。 6 q1 o* W$ Z$ N; T
◆与其它机器上的对象或程序进行对话,构成分布式应用程序。 ( }) z5 | t) Y( ^
Microsoft推出Windows 98和Windows NT 5.0后,整个操作系统的核心都围绕着COM来建立。我们可以把Windows系统看作是一系列的COM接口,在需要是可以调用这些接口。如DirectX就是一系列的COM接口服务程序,通过它可以进行高性能的Windows图形程序设计。
3 N$ E+ }' H3 v! m用COM技术开发的应用程序从理论上说是客户/服务器模式的程序。程序员可以使用一系列的COM服务程序来构造他们自己的应用程序,这些服务程序可以根据需要随时嵌入到主程序中。在分布式系统中,可以通过网络来访问这些服务程序。将来,操作系统和整个网络可能会被看作是一套以COM对象形式提供的服务集。一部分程序员负责建立这些服务,而另一部分程序员只负责如何调用它们。其目的是实现软件的即插即用。 ' ^ d, C% h, _( R5 |
开发COM应用程序是比较复杂的,通常需采用ActiveX模板库(ATL)来编程。在这里我们推荐采用C++ Builder来开发COM程序,Inprise(Borland)公司的面向对象技术一直处于世界领先水平,C++ Builder采用可视化方法,隐藏了ATL的实现细节,自动生成COM接口所需的代码。 6 J1 n3 O1 h3 d7 o7 `0 x* m# V
以下的程序举例采用C++ Builder 4.0 编制,在中文Windows98环境下运行。
0 \! E1 ~+ `9 r# p$ i e) U% w2.建立COM服务程序
; c, |. x; S) Z COM服务程序有三种形式,第一种是驻留在本地机器上以DLL形式提供,该服务程序被调用时,嵌入到调用程序的线程中运行;第二种是驻留在本地机器上以EXE形式提供,该服务程序被调用时将占用独立的线程运行;第三种驻留在远端机器上以EXE形式提供,服务程序通过网络被调用,它在远端机器上运行,结果通过网络返回调用者。
4 n+ D2 L* I' r$ e/ g: r 在此采用第一种形式建立COM服务程序,这也是最常用的形式,DirectX就是采用这种形式提供的。
! j( r) H7 f% ?% K' C C++ Builder建立COM服务程序的方法如下:
1 u9 L8 j& G0 V8 ]* o. o6 e: |2.1创建支持COM接口对象的动态连接库文件: : F- l6 {; Z/ ^ E& {
◆打开File/New/ActiveX项目页,选择ActiveX Library; * _/ x& I, J8 B7 p: `$ H/ `( x
◆选择Save All 将项目以PCOMServer文件名保存;此时C++ Builder 自动生成如下的文件:
; i7 v7 Q# _- c! b( I# ]4 e PCOMServer.bpr:工程的项目文件; 8 ]" P9 Y0 H3 [1 F- Y1 `
PCOMServer.h,PCOMServer.cpp:支持COM对象的动态连接库源文件,其中有许多函数用于COM接口对象的自动装配,大家不用去编辑它们; . g1 k6 j% z! S+ X4 K
PCOMServer_ATL.h,PCOMServer_ATL.cpp:ATL形式的文件供C++ Builder编译器调用,大家也不要去编辑它们。
/ s- k' G% k) U% }% I' Y◆打开Project/Options/Linker 属性页不选中Use dynamic RTL选项,打开Project/Options/Packages属性页不选中Builder with runtime packages选项,这两步操作可以使开发的COM动态连接库不依赖C++ Builder的VCL动态连接库,有利于独立发行,但在一般情况下还是建议选中这两项。 ; p) ?5 ?( s. Z; }* a/ J
2.2建立COM接口对象 3 K; |3 ]' B& N" O2 ?
- S" N. J% ^6 M! J. Z 8 J( T4 a. f8 l1 o" }0 c' a- t
打开File/New/ActiveX属性页,选择Automation Object表示向服务程序中插入一个自动类型的COM对象,我们选择这种类型的COM对象是为了可以自动注册,并且自动支持可以被其他语言调用。此时出现如下的对话框,输入COM类的名字MyCOM即可,对话框中的其它选项用于规定COM对象的性质,可查看帮助信息。
9 V4 k }% }6 Q2.3通过类型库编辑器编辑COM对象中相应接口对象的属性和方法
% L; X b( |; S& G a8 u 9 a. |# M" F' o1 n: Z( c$ t% {
5 ~) g+ C- y" z2 B9 X: z
此时自动进入类型库编辑器,类型库用于存储COM对象的说明,是一个可以被多种语言调用的头文件包。在类型库中,可以定义COM对象的接口,定义接口对象的属性和方法等。类型库编辑器如下所示: D; p7 t9 E6 k
可以看出此时自动产生了MyCOM类的一个接口类IMyCOM,在COM应用软件中我们实际上是与接口对象打交道,下面通过类型库编辑器为IMyCOM接口定义方法和属性。
+ Q' ?% E; P! [7 D) G◆单击编辑器顶部的Method按钮; ' K5 c9 z5 w0 R% w
◆在Arributes页面的Name字段中输入方法的名称,本例中是AddInt用于整数加法; 2 {4 e0 D- h0 ^. ~2 F
◆在Parameters页面中,单击Add按钮编辑方法中的参数;
; Q# M* k& { Vx和y是输入的两个整数,ret用于返回运算的结果,必须定义为指针型
4 u, J/ I0 l" `8 l, t◆切换到Flags页面,可以对接口的属性作调整;
+ S$ [+ G4 ^, `; b% q0 [◆在Text页面中可以检查生成的IDL代码:
& Y7 }: p% M9 _+ J, l[id(0x00000001)] + q4 F' L( c* d3 M, ]0 ?$ R9 i- ]
5 _+ `2 |# p5 h+ w+ Q- u7 z: P/ x 7 w& ]5 w0 [# A9 D
HRESULT _stdcall AddInt([in] int x, [in] int y, [out, retval] int * ret );
/ f: U; T: [( L% y! z/ B◆单击Refresh按钮,此时可以关闭类型库编辑器。当需要为接口添加新的属性和方法时,可以通过View/Type Library重新打开编辑器。选择Save All用C++ Builder提供的缺省文件名保存类型库的相关文件如下: ' Z0 `6 t$ p* X4 b1 t8 R. Z! ]0 w3 [
PCOMServer.TLB: 类型库文件; , F" L6 N9 J( S( F, ?
PCOMServer_TLB.cpp:包含COM接口和对象的说明,其主要目的是方便访问,在客户程序中需将本文件包含到客户程序的工程中; 1 G3 @' v: R, W
PCOMServer_TLB.h: PCOMServer_TLB.cpp的头文件,通过#include引入到客户程序中。 / u$ X+ a$ b$ Y: C
MyCOMImpl.cpp: 该文件是我们需要编写程序代码的地方,实现类型库定义的接口对象的方法和属性; # r1 I( ?7 b7 }( r0 f
MyCOMImpl.h: MyCOMImpl.cpp的头文件。
: O- P6 y5 _% J1 d( v& T2.4 实现COM接口中的方法
& m- Q) J# w, u5 C, c+ \ 打开MyCOMImpl.cpp文件会发现我们在类型库编辑器中定义的方法,为该方法编写代码如下:
! V- g% o! R8 D1 Z2 d STDMETHODIMP TMyCOMImpl::AddInt(int x, int y, int* ret) / U9 s1 K" X3 h! }
{ " t+ W$ C4 S z# O
*ret=x+y;
. X& ^+ b( `+ E! q( w. X! s/ C return S_OK; O3 b5 @1 n0 J9 x* j% T& |6 T
}
& x+ X. N/ p7 q, y1 H6 e2.5 生成DLL文件并注册COM对象 2 m' V4 m% B6 d
◆选择Project/Builder PCOMServer 生成PCOMServer.DLL文件。
! ^) v2 r/ a3 I2 I. {◆打开类型库编辑器,单击Register按钮完成对COM对象的注册。
9 `3 ^. z& a6 M+ }2 J2 e* | 通过Windows任务栏中的Run菜单运行REGEDIT程序,在Windows注册表的HKEY_CLASSES_ROOT键下查找到PCOMServer.MyCOM子键,PCOMServer为DLL文件的名字,MyCOM为COM对象的名字,在下面可以看到该COM对象的全局唯一描述符CLSID如下: [4 L# D7 o7 j; r* M+ M$ c5 d9 r
{59834F03-49F1-11D3-B85B-00E09804A418}
2 `) b8 ~6 o& l* k* m5 J3 ]) X 注意:不同的机器生成的描述符不同.
% s9 m* P+ X X2 H6 U/ a 在HKEY_CLASSES_ROOT键下查找到CLSID子键,在它下面找{59834F03-49F1-11D3-B85B-00E09804A418}子键,下面有如下的条目:
' Y; }& j) J9 W, ~3 R* x ] InprocServer32:存储PCOMServer.DLL的路径目录;
. D( u0 x" ?- ?/ F. \4 h+ I' ~ ProgID:存储COM对象的注册名:PCOMServer.MyCOM; ' s6 X% _/ Y* N* B$ W6 d4 _
Typelib:存储COM对象的CLSID值{59834F03-49F1-11D3-B85B-00E09804A418}。
: F! P i. w P) i# K9 g, v COM对象就是通过在注册表中的纪录实现DLL与客户程序的自动连接。
# j/ {3 q- r: G/ s/ d3.建立COM客户程序 . ^7 V: w9 X* E+ {
客户程序将访问PCOMServer.DLL服务程序中的MyCOM对象,这些对象的说明保存在前面所述的TLB文件中。我们可以直接将PCOMServer_TLB.cpp加入到客户程序的项目文件中,并在客户程序中引用PCOMServer_TLB.h文件;也可以通过Project/Import Type Library引用PCOMServer_TLB.TLB文件,重新生成.cpp和.h文件,自动完成上述过程。 % q: F. Z- n I4 E; z7 `" o! n& X- B
客户程序的编程重点是实现对服务程序中COM对象的方法的调用,调用的方法有多种,都是通过所谓的代理接口来完成的,这些代理接口在PCOMServer_TLB.h中有详细的定义,从这些定义中可以看出这些代理接口调用对象方法的过程。 4 {, }9 p( y" Y) ^5 T; k! ], c
PCOMServer_TLB.h文件很重要,包含了调用MyCOM对象的各种接口信息,该文件主要内容如下:
2 d% a# j; x- h, t8 k1 K- U// Type Lib: D:\CAI\com\PCOMServer.tlb
/ J3 O7 ?2 E8 `9 b2 L0 Q// IID\LCID: {5BD378E5-4B57-11D3-B85B-00E09804A418}\0 0 @+ X& R5 O, K$ O2 H2 A$ L1 C2 p
// Helpfile: ; k6 L# H9 `* ~( n; j! \. h- S
// DepndLst:
9 f" q# U, A. M9 n9 a% j// (1) v2.0 stdole, (C:\WINDOWS\SYSTEM\STDOLE2.TLB)
9 H! g& Z$ U7 g- r// (2) v4.0 StdVCL, (C:\WINDOWS\SYSTEM\STDVCL40.DLL)
2 C7 N' o' _' D7 | m% n// ************************************************************************ 6 w* {1 {$ I1 v l: Y# a( J7 ~
#ifndef __PCOMServer_TLB_h__ 7 u) L" p* d( q, O/ f7 z4 y0 Z
#define __PCOMServer_TLB_h__
& _; h8 R: ^5 N( G2 n0 T#pragma option push -b -w-inl 9 O" g: m; M/ v1 Z) k
#include <vcl/utilcls.h> . ~ S% z$ P( R$ R4 q. v% d! @$ J
#if !defined(__UTILCLS_H_VERSION) || (__UTILCLS_H_VERSION < 0x0101) * s- D, o3 v+ g! T+ ^; [4 y
#error "This file requires an newer version of the header file UTILCLS.H"
$ K$ p2 J+ Q2 c+ C5 T: t r#endif
$ Y5 t1 d9 d9 ^. K % T0 i0 |% K5 z& m- D3 v- J, Q
#include <olectl.h>
- N6 Y1 C. N7 O7 T6 ^#include <ocidl.h> H* s$ I! a7 C' ?5 `# f0 ~4 K
#if defined(USING_ATLVCL) || defined(USING_ATL)
/ M1 l9 L9 `9 |% r& N#if !defined(__TLB_NO_EVENT_WRAPPERS) 9 @) `9 e* X$ B4 p, s9 Q* v) A1 s
#include <atl/atlmod.h> 6 c+ q% A7 F! { ?3 n4 E3 d
#endif 8 t2 a Z7 [, S4 z2 z7 \+ {
#endif
" `3 y/ S3 E: ]& k; s 9 ^- E; }/ e: i( W6 C% J: h
namespace Stdvcl {class IStrings; class IStringsDisp;} 6 ]. `7 T7 u8 F. n$ R1 p" e
using namespace Stdvcl;
0 w6 {/ ^# |4 q: s
: w# P) A) m! _: Snamespace Pcomserver_tlb
5 F- k/ P0 S9 j5 @% G6 X{ ! J5 S7 C! m! \1 ^0 a1 Q: f
DEFINE_GUID(LIBID_PCOMServer, 0x5BD378E5, 0x4B57, 0x11D3, 0xB8, 0x5B, 0x00, 0xE0, 0x98, 0x04, 0xA4, 0x18);
8 a# j/ d: A. p8 cDEFINE_GUID(IID_IMyCOM, 0x5BD378E6, 0x4B57, 0x11D3, 0xB8, 0x5B, 0x00, 0xE0, 0x98, 0x04, 0xA4, 0x18);
- F' o4 S2 e! q1 q/ _! H; N$ c" G; ZDEFINE_GUID(CLSID_MyCOM, 0x5BD378E8, 0x4B57, 0x11D3, 0xB8, 0x5B, 0x00, 0xE0, 0x98, 0x04, 0xA4, 0x18); 7 X/ W2 N4 S" l2 `
interface DECLSPEC_UUID("{5BD378E6-4B57-11D3-B85B-00E09804A418}") IMyCOM; 4 X2 W: W! A! R
typedef IMyCOM MyCOM; : V$ C" {2 \6 a- I: x5 A! `
: q* N; l/ p2 c# V0 r3 N: L#define LIBID_OF_MyCOM (&LIBID_PCOMServer)
6 v% `7 V* c' t2 |( O1 d! [2 o; uinterface IMyCOM : public IDispatch 3 P, ~( y$ e: O+ |7 Q& A; J4 ]3 i8 u
{
* c( N- K% N1 ?public: 7 V' d8 [; _5 u7 t5 K; D9 X
virtual HRESULT STDMETHODCALLTYPE AddInt(int x/*[in]*/, int y/*[in]*/, int* ret/*[out,retval]*/) = 0; // [1] / I8 ]6 D1 @* P p! r* I- a
#if !defined(__TLB_NO_INTERFACE_WRAPPERS) ( r' g; R, J& a9 ~
int __fastcall AddInt(int x/*[in]*/, int y/*[in]*/) 4 U6 A. \2 G6 }5 P9 ~; C
{
! Q# Q, Y8 V0 l( r) H2 b int ret; 5 ~- e, S1 A9 K$ \- K
OLECHECK(this->AddInt(x, y, &ret));
" v7 p9 m$ u( j3 j return ret; 2 ?7 D: s; I2 J% B& f3 m. Y
} " a- M$ j t# B: d* C
#endif // __TLB_NO_INTERFACE_WRAPPERS 9 _' S: L1 Y4 Z7 r: K) T6 t
};
) [1 t5 X' M; T- J% T4 ^4 C#if !defined(__TLB_NO_INTERFACE_WRAPPERS)
6 h7 m/ ^1 o' E- O" j: K+ ktemplate <class T /* IMyCOM */ > ! l; L4 e0 w; G# N, ]( i; a
- I2 o$ [7 k) ?! F7 V
class TCOMIMyCOMT : public TComInterface<IMyCOM>, public TComInterfaceBase<IUnknown> ) Q# ]; B5 s$ d' P8 V- e" O
{ & Z4 k7 ?8 e/ |. L# m) T6 t
public:
0 X1 `9 x* \: e TCOMIMyCOMT() {}
' @: J0 B0 z! ~# l% @& y TCOMIMyCOMT(IMyCOM *intf, bool addRef = false) : TComInterface<IMyCOM>(intf, addRef) {}
4 m5 R4 f7 s6 h3 I% I6 I TCOMIMyCOMT(const TCOMIMyCOMT& src) : TComInterface<IMyCOM>(src) {}
6 \/ t0 a) d! W, i ~ TCOMIMyCOMT& operator=(const TCOMIMyCOMT& src) { Bind(src, true); return *this;} 0 U; S8 ~, F6 y D" z/ Z. H
HRESULT __fastcall AddInt(int x/*[in]*/, int y/*[in]*/, int* ret/*[out,retval]*/); 2 A) h* ?$ k& i& r% C+ E: z; K Q0 W
int __fastcall AddInt(int x/*[in]*/, int y/*[in]*/); ) |) M7 Z T# x; z
}; ; U' h! M0 z- q6 i2 a
typedef TCOMIMyCOMT<IMyCOM> TCOMIMyCOM; 7 W M# p7 g5 F. h- c
( ]" p9 a3 G' {2 f7 @template<class T>
% k8 b. [4 z7 A' j7 s1 _: [! [% cclass IMyCOMDispT : public TAutoDriver<IMyCOM> - ^' L+ r( X' `$ P
{ 6 D; ^" h3 I: N1 Q9 R8 ?
public: ! ~$ G$ x* u2 e& r& p: S% {" h7 ]
IMyCOMDispT(){} # w* L( S& Q% D# P1 f/ P$ I2 W
IMyCOMDispT(IMyCOM *pintf)
2 Y" F/ C/ P/ [ v- {: D. }: S { ( c1 `' G+ P2 Y; Y$ t8 Y% `) g' C
TAutoDriver<IMyCOM>::Bind(pintf); _; _5 {2 E+ H, L* B9 `
}
; G# D) y: h9 P IMyCOMDispT& operator=(IMyCOM *pintf)
4 E+ L, h% g2 B" H1 b { s; S0 h- G0 u5 z- K
TAutoDriver<IMyCOM>::Bind(pintf);
8 N! c# K' z7 x return *this; 9 f, d* h) D' D2 G: k- c: X
}
0 u: z9 ]' ~$ R# v$ ? HRESULT BindDefault(/*Binds to new instance of CoClass MyCOM*/) ; i" ^* i% f o
{
2 [- F% e/ ^0 G* C9 a return OLECHECK(Bind(CLSID_MyCOM)); j3 c2 i5 j5 |# S( J1 v/ x
}
6 `3 _1 [) G4 _) I HRESULT BindRunning(/*Binds to a running instance of CoClass MyCOM*/) 4 Y% e0 F' ^8 j* t$ l. b
{ ! p- F: r a2 ]
return BindToActive(CLSID_MyCOM);
/ t: y$ E k+ ^* U) a } N2 v# V( B! }$ \% r$ q9 q" f8 s
HRESULT __fastcall AddInt(int x/*[in]*/, int y/*[in]*/, int* ret/*[out,retval]*/);
( p; i+ y: [0 p7 U$ C* x: m int __fastcall AddInt(int x/*[in]*/, int y/*[in]*/);
- r/ r/ r m2 ^6 m% G( w}; ' F% G Z1 S% }* O( e# k4 F
typedef IMyCOMDispT<IMyCOM> IMyCOMDisp;
- m/ d7 ]0 w3 k. u" O: T
/ e2 N6 F/ _+ W( Stemplate <class T> HRESULT __fastcall / n Q$ [# k1 G( f/ J9 x, C
TCOMIMyCOMT<T>::AddInt(int x/*[in]*/, int y/*[in]*/, int* ret/*[out,retval]*/) V& c0 N2 h) n& u+ E, c
{ 9 ]" ?" D( F. E% X
return (*this)->AddInt(x, y, ret); & \4 ~- g& M1 i4 C- O
}
* I9 u8 }( x9 A R( O 3 @) V( c9 a9 W$ X8 W1 q8 I& Q
template <class T> int __fastcall
; o4 J! q" V+ J& ?; X, G8 \3 BTCOMIMyCOMT<T>::AddInt(int x/*[in]*/, int y/*[in]*/)
) l8 d: } m' q0 E, k{ 2 u" H8 ?4 @& C, ~- n7 E
int ret; 2 O, q0 ^! [0 _! w7 | c, d9 O
OLECHECK(this->AddInt(x, y, &ret));
* [5 m! \' ]8 A/ W1 d- H; X9 d return ret; $ k2 Y T) G7 z
} ! t; S A! J: ~7 @8 D
; W$ |* K# X4 d1 e: R2 H
template <class T> HRESULT __fastcall
( b& L" r6 Q# A5 P6 O. {IMyCOMDispT<T>::AddInt(int x/*[in]*/, int y/*[in]*/, int* ret/*[out,retval]*/) W% j) G2 A2 d5 q. P7 B
{ 5 J, _! [9 c$ H. C4 R j$ X
static _TDispID _dispid(*this, OLETEXT("AddInt"), DISPID(1));
# V" p& S' ]5 ]6 @ TAutoArgs<2> _args; + q; _( ]' P% l
_args[1] = x /*[VT_INT:0]*/; ) L( V( l) j$ @ D
_args[2] = y /*[VT_INT:0]*/; + _/ H4 B; g1 Z5 H9 C! B- P
return OutRetValSetterPtr(ret /*[VT_INT:1]*/, _args, OleFunction(_dispid, _args));
8 T9 K. _1 A; K( j& l}
) p: \+ H# ?' _: A4 K( z
$ d6 O* ?/ G; Q& Z6 etemplate <class T> int __fastcall 0 ~, Z5 z+ x, X( Y3 _/ O
IMyCOMDispT<T>::AddInt(int x/*[in]*/, int y/*[in]*/) % v" l# S* K" f* D1 B
{
. G+ ^6 ?; s- ]+ }* w! G; \2 m int ret; & [: C7 t$ g0 o3 e
this->AddInt(x, y, &ret);
5 Z4 R# v- v2 F# K$ t. h0 y m return ret;
3 p P3 v# w. ~3 a} ' w D2 A; B# I* e( f% r
9 @- |/ \: r9 c# H& [4 otypedef TCoClassCreatorT<TCOMIMyCOM, IMyCOM, &CLSID_MyCOM, &IID_IMyCOM> CoMyCOM;
. U+ a: D1 r! b- n8 \6 a2 {#endif // __TLB_NO_INTERFACE_WRAPPERS
% B( _6 O% {# e) C8 |}; // namespace Pcomserver_tlb 1 p8 R; Y. D( q/ S6 |. q/ m( i0 e# R# }
#if !defined(NO_IMPLICIT_NAMESPACE_USE)
. W+ L5 ~, x8 o4 ^' K6 ?using namespace Pcomserver_tlb;
0 r' X% ]& {) r8 }/ Q) M B#endif ( q6 G* f+ r0 i9 u6 {
#pragma option pop % H8 z) v$ `7 S' t
#endif // __PCOMServer_TLB_h__ 9 d+ \1 }. I7 C" h- b8 R4 `: U
下面是文件中说明的主要对象及其定义: 1 U7 X- [ n2 m: {; ]. C8 W( |5 V
interface IMyCOM : public IDispatch
; n: Y% v. T, o- a! V5 N5 m+ Zclass TCOMIMyCOMT : public TComInterface<IMyCOM> . t2 u* Q0 H7 g- _
class IMyCOMDispT : public TAutoDriver<IMyCOM>
. ~4 k% Z2 A) g$ Q" F' \" Hclass CoMyCOM: public CoClassCreator
0 q* }$ `: W' l; L" Z' `◆IMyCOM:通过IDispatch接口来调用对象的方法,该接口可以使对象被不支持虚拟函数表(VTable)的语言(如Visual Basic)说调用。这是一种很慢很苯的接口调用方式。 # R( v8 E+ E( M- F& i
◆TCOMIMyCOMT:通过所谓的智能接口来调用对象的方法,既可以实现IDispatch调用,也可以采用VTable进行调用,从而实现最快的调用速度。
) {/ y1 _' {4 \# z$ x8 j7 `* P◆IMyCOMDispT:通过disp接口来调用对象的方法,可以提高Idispatch接口的访问速度,但还是比不上VTable接口。
0 @2 T5 S! c. A: C& F" s◆CoMyCOM:通过使用CoClassCreator可以自动产生TCOMIMyCOM代理的实例。
' Y6 w" l4 z8 f0 a& ` 下面介绍一下实现智能接口和Disp接口调用的客户程序。这个客户程序很简单,有两个按钮分别完成两种接口调用的方法,一个编辑框显示结果。
7 G- \$ i4 D9 ?6 G◆智能接口的VTable调用方法如下: 5 p! T# t" ^8 C/ @
int x=6,y=6;
2 S1 p9 x N5 U9 u& s7 E) K* x) S) X TCOMIMyCOM O;
& d( q; T8 p( d4 T# w+ i, H" @ O=CoMyCOM::Create(); //通过CoClassCreator完成初始化 : V" r5 j$ V1 X2 ?: _
O->AddInt(x,y,&y); //Vtable形式调用
& C: \" `: I3 K Edit1->Text=IntToStr(y); , y A7 |1 {: g% c. w
◆DISP接口的调用方法如下: ' _' u, u: W9 V+ N0 s
int x=6,y=6; ; n) ?3 ?: T+ Y4 w& J$ }) c) l
IMyCOMDisp app;
b# q; i6 X c app.BindDefault(); //通过Bind完成初始化
5 W3 N( r$ c0 V$ ~1 c% O& j app.AddInt(x,y,&y); //Disp形式调用 ! w6 U9 |0 O8 h4 a" y, ]2 g6 C1 L
Edit1->Text=IntToStr(y);
# V. A, v6 e7 z4.小结 2 y. n# U# |& T( i0 O, o$ T
上面的程序举例是很简单的,但却详细说明了COM应用软件的开发过程。COM技术不是一个编程语言,而是一种编程规范和方法。采用COM技术可以开发功能强大的软件,有利于分布式应用技术的实现,有利于多人合作开发,也可以帮助我们理解Windows系统本身。COM的接口技术是比较复杂的,想进一步了解COM技术可参阅清华大学出版社的《COM技术内幕》一书。
: X# C: z: w7 H3 s0 c C++ Builder是开发COM应用软件的好工具,它隐含了COM实现的细节,我们只需与它打交道就可以开发完善和强大的COM应用程序。希望有更多的人转到COM应用软件的开发上来,COM技术是软件技术未来的发展方向,是实现软件工程中软件即插即用的有效途径。
0 e' x6 y, L9 O ' ~9 R9 w1 u& _4 s) o% h8 S
|