|
蔡倩 3 R- K, R. W9 l% a1 {& r: X+ |
主题词: COM ActiveX C++ Builder
9 r; d n" ?- I& ^: s- s7 v! G2 j1.COM技术概述
6 \- E8 p& k7 g0 PCOM表示Component Object Model(组件对象模型),它是Microsoft大力推广的软件开发技术。采用COM规范开发的应用软件具有强大的功能,主要有如下几点:
7 s/ U8 r B9 V4 [+ y+ ^◆COM是二进制编程规范,可以编写被多种语言使用的代码。
1 q G5 K# Y& \9 Y1 `◆用于创建ActiveX控件。
1 A( d9 z4 o3 }- k+ J◆通过OLE Automation 控制其它的程序。
7 B$ o9 Y* @. m3 @ M◆与其它机器上的对象或程序进行对话,构成分布式应用程序。 1 G0 l+ `" M* l7 z0 H+ h. D' [
Microsoft推出Windows 98和Windows NT 5.0后,整个操作系统的核心都围绕着COM来建立。我们可以把Windows系统看作是一系列的COM接口,在需要是可以调用这些接口。如DirectX就是一系列的COM接口服务程序,通过它可以进行高性能的Windows图形程序设计。 3 M2 t7 v# C3 _7 Y, s6 U/ h3 ~
用COM技术开发的应用程序从理论上说是客户/服务器模式的程序。程序员可以使用一系列的COM服务程序来构造他们自己的应用程序,这些服务程序可以根据需要随时嵌入到主程序中。在分布式系统中,可以通过网络来访问这些服务程序。将来,操作系统和整个网络可能会被看作是一套以COM对象形式提供的服务集。一部分程序员负责建立这些服务,而另一部分程序员只负责如何调用它们。其目的是实现软件的即插即用。 7 b+ k1 r* E: ~
开发COM应用程序是比较复杂的,通常需采用ActiveX模板库(ATL)来编程。在这里我们推荐采用C++ Builder来开发COM程序,Inprise(Borland)公司的面向对象技术一直处于世界领先水平,C++ Builder采用可视化方法,隐藏了ATL的实现细节,自动生成COM接口所需的代码。
3 S3 S* V, B0 \8 V% t A以下的程序举例采用C++ Builder 4.0 编制,在中文Windows98环境下运行。
( ?2 x4 M; Q) t; Y2.建立COM服务程序
/ m7 t6 |/ H, z/ l COM服务程序有三种形式,第一种是驻留在本地机器上以DLL形式提供,该服务程序被调用时,嵌入到调用程序的线程中运行;第二种是驻留在本地机器上以EXE形式提供,该服务程序被调用时将占用独立的线程运行;第三种驻留在远端机器上以EXE形式提供,服务程序通过网络被调用,它在远端机器上运行,结果通过网络返回调用者。 % H/ j" Z7 ?4 p4 X2 o/ K5 G( b
在此采用第一种形式建立COM服务程序,这也是最常用的形式,DirectX就是采用这种形式提供的。 % k7 F7 a! T& ~' W: t* M1 n( U
C++ Builder建立COM服务程序的方法如下:
4 e. X: {6 g% ~5 X/ E2.1创建支持COM接口对象的动态连接库文件:
0 V. l( Z2 f: J+ E' Y) V! d◆打开File/New/ActiveX项目页,选择ActiveX Library;
) ]0 G4 d/ x0 I; [( d5 E& h◆选择Save All 将项目以PCOMServer文件名保存;此时C++ Builder 自动生成如下的文件: g% e& Z; q" k; _
PCOMServer.bpr:工程的项目文件; : K1 g& A, E/ ?9 Y. p- B# t
PCOMServer.h,PCOMServer.cpp:支持COM对象的动态连接库源文件,其中有许多函数用于COM接口对象的自动装配,大家不用去编辑它们;
1 D8 _# }6 [' X7 b) \9 O& G PCOMServer_ATL.h,PCOMServer_ATL.cpp:ATL形式的文件供C++ Builder编译器调用,大家也不要去编辑它们。 k- j( ^( q( t3 P
◆打开Project/Options/Linker 属性页不选中Use dynamic RTL选项,打开Project/Options/Packages属性页不选中Builder with runtime packages选项,这两步操作可以使开发的COM动态连接库不依赖C++ Builder的VCL动态连接库,有利于独立发行,但在一般情况下还是建议选中这两项。
8 e3 s r% i2 v# C* D2.2建立COM接口对象
7 i# s) P& d& m4 t
$ J* v; p; U2 n: g8 l6 V5 m. i
! f# G* Y) D1 y6 e6 P 打开File/New/ActiveX属性页,选择Automation Object表示向服务程序中插入一个自动类型的COM对象,我们选择这种类型的COM对象是为了可以自动注册,并且自动支持可以被其他语言调用。此时出现如下的对话框,输入COM类的名字MyCOM即可,对话框中的其它选项用于规定COM对象的性质,可查看帮助信息。
* T( m% Y! _: m1 T2.3通过类型库编辑器编辑COM对象中相应接口对象的属性和方法 ) u4 ?/ y/ P$ Q! i9 |
* u' z N, D* f. L/ L* @
" c; s* v1 z6 x% f3 K) k) b
此时自动进入类型库编辑器,类型库用于存储COM对象的说明,是一个可以被多种语言调用的头文件包。在类型库中,可以定义COM对象的接口,定义接口对象的属性和方法等。类型库编辑器如下所示:
' \* }8 r- l' A% o7 n, j7 {* P 可以看出此时自动产生了MyCOM类的一个接口类IMyCOM,在COM应用软件中我们实际上是与接口对象打交道,下面通过类型库编辑器为IMyCOM接口定义方法和属性。
8 @+ J/ O/ t5 y. Q◆单击编辑器顶部的Method按钮;
+ w8 C7 C; l$ o" P* F◆在Arributes页面的Name字段中输入方法的名称,本例中是AddInt用于整数加法; 3 i9 V/ g6 D9 `, s) g4 _' I9 c8 d
◆在Parameters页面中,单击Add按钮编辑方法中的参数;
, x0 L7 ^& m) [( _/ h& K, zx和y是输入的两个整数,ret用于返回运算的结果,必须定义为指针型
% f1 \# \5 U9 k, X9 b9 i0 {/ }1 t$ i. G◆切换到Flags页面,可以对接口的属性作调整;
( w, h7 E" p" P% K3 N) h8 A◆在Text页面中可以检查生成的IDL代码: * X) r1 {7 |; i! q
[id(0x00000001)] 9 |. a- n7 y* F% c1 u
0 O9 j6 q9 m$ P9 a4 ^2 ~
4 _& ^9 d& L+ [2 ~* a9 G. ]HRESULT _stdcall AddInt([in] int x, [in] int y, [out, retval] int * ret );
% h( \1 x+ N8 b! f2 v# Z1 P◆单击Refresh按钮,此时可以关闭类型库编辑器。当需要为接口添加新的属性和方法时,可以通过View/Type Library重新打开编辑器。选择Save All用C++ Builder提供的缺省文件名保存类型库的相关文件如下:
# ]) T# u1 p9 ]4 m7 FPCOMServer.TLB: 类型库文件; H- q4 s$ ~# \1 \4 v" t8 M4 F
PCOMServer_TLB.cpp:包含COM接口和对象的说明,其主要目的是方便访问,在客户程序中需将本文件包含到客户程序的工程中; 0 @& K# L4 c/ J- ~! z, s
PCOMServer_TLB.h: PCOMServer_TLB.cpp的头文件,通过#include引入到客户程序中。 4 d: p7 ~9 m: V4 B
MyCOMImpl.cpp: 该文件是我们需要编写程序代码的地方,实现类型库定义的接口对象的方法和属性; ( d; U$ t i: u% P% _( W, m% H& K
MyCOMImpl.h: MyCOMImpl.cpp的头文件。 6 C! w- C& E3 _8 r$ \/ v, ^9 {% Z
2.4 实现COM接口中的方法
( M- a! Z6 i8 t) Z 打开MyCOMImpl.cpp文件会发现我们在类型库编辑器中定义的方法,为该方法编写代码如下: , u9 u6 g$ a6 [4 [* Y: F. f
STDMETHODIMP TMyCOMImpl::AddInt(int x, int y, int* ret) 9 q+ ~, q& K, t+ P: I: ^
{
6 I8 f' ^* F; h& w$ y. C" c0 ~ *ret=x+y;
2 B$ v0 w4 e" F h; o3 b return S_OK; + E0 ?9 v v% |2 T+ W' K6 f; T9 h
}
4 G+ X1 U3 o! Q& A# L1 ?2.5 生成DLL文件并注册COM对象 & ^2 W: c; C, J2 Z& u% y
◆选择Project/Builder PCOMServer 生成PCOMServer.DLL文件。
( m% u0 \' W& c* l9 \: e7 O◆打开类型库编辑器,单击Register按钮完成对COM对象的注册。 : N+ K! y" q- N
通过Windows任务栏中的Run菜单运行REGEDIT程序,在Windows注册表的HKEY_CLASSES_ROOT键下查找到PCOMServer.MyCOM子键,PCOMServer为DLL文件的名字,MyCOM为COM对象的名字,在下面可以看到该COM对象的全局唯一描述符CLSID如下:
- }* o' E/ |/ d( _8 f% X8 }/ [ {59834F03-49F1-11D3-B85B-00E09804A418}
0 o, w U9 t J/ A9 ^/ R9 C& [7 A 注意:不同的机器生成的描述符不同. 9 ~- P3 Y4 A$ u b
在HKEY_CLASSES_ROOT键下查找到CLSID子键,在它下面找{59834F03-49F1-11D3-B85B-00E09804A418}子键,下面有如下的条目: # K9 Y: d* E8 K1 \
InprocServer32:存储PCOMServer.DLL的路径目录;
% t- }1 R) x: z ProgID:存储COM对象的注册名:PCOMServer.MyCOM;
0 `' A" l8 r+ I* H' ~" Y* o! K Typelib:存储COM对象的CLSID值{59834F03-49F1-11D3-B85B-00E09804A418}。
1 I1 W3 X* Y. s$ T" a5 s7 |* R COM对象就是通过在注册表中的纪录实现DLL与客户程序的自动连接。
1 O0 _. U: c8 t3.建立COM客户程序
. N' V4 a" G, }; {" t6 Z客户程序将访问PCOMServer.DLL服务程序中的MyCOM对象,这些对象的说明保存在前面所述的TLB文件中。我们可以直接将PCOMServer_TLB.cpp加入到客户程序的项目文件中,并在客户程序中引用PCOMServer_TLB.h文件;也可以通过Project/Import Type Library引用PCOMServer_TLB.TLB文件,重新生成.cpp和.h文件,自动完成上述过程。 9 v% J/ ^! o/ P7 h7 r! V
客户程序的编程重点是实现对服务程序中COM对象的方法的调用,调用的方法有多种,都是通过所谓的代理接口来完成的,这些代理接口在PCOMServer_TLB.h中有详细的定义,从这些定义中可以看出这些代理接口调用对象方法的过程。 $ ~/ ^, n9 `- Z" k" U( G4 w4 r% U$ ?
PCOMServer_TLB.h文件很重要,包含了调用MyCOM对象的各种接口信息,该文件主要内容如下: * @1 Z% G% W s6 E
// Type Lib: D:\CAI\com\PCOMServer.tlb
6 Q- `" B' T. I' H2 c4 V. \2 U9 @// IID\LCID: {5BD378E5-4B57-11D3-B85B-00E09804A418}\0 0 ~5 H6 I7 S6 Y O9 e5 k
// Helpfile:
3 P9 U3 s, i& W4 \- P: U// DepndLst:
1 U6 |! A2 y- o$ Q# }. x// (1) v2.0 stdole, (C:\WINDOWS\SYSTEM\STDOLE2.TLB) 3 C) `% u$ Z3 U9 O
// (2) v4.0 StdVCL, (C:\WINDOWS\SYSTEM\STDVCL40.DLL)
+ B3 ^ W7 j: H. X// ************************************************************************
# e8 b! S1 Y& t" X9 I#ifndef __PCOMServer_TLB_h__ 8 \0 m& Q( o' a- y! N1 h
#define __PCOMServer_TLB_h__ 7 q$ Q4 v! o% {
#pragma option push -b -w-inl 8 D7 A4 v' q+ [5 Z. s8 i5 l+ d
#include <vcl/utilcls.h> 7 y: C6 G. ?' y6 t
#if !defined(__UTILCLS_H_VERSION) || (__UTILCLS_H_VERSION < 0x0101) ; \% L0 z- k8 n N4 t/ n8 S" V. s
#error "This file requires an newer version of the header file UTILCLS.H" 6 L8 d7 e- D4 ]8 t" i
#endif : `# L5 @: C( X$ ? ]; S
5 \* c- [" t7 I" c4 ~
#include <olectl.h> 1 i- s0 O; T4 Q$ K% b* g2 Y, k* F
#include <ocidl.h>
9 E8 v) f) r3 x; t#if defined(USING_ATLVCL) || defined(USING_ATL)
$ d3 c7 H) q2 T#if !defined(__TLB_NO_EVENT_WRAPPERS)
! Q) K( _2 t) r8 V$ l1 A#include <atl/atlmod.h> ' j7 H0 \' G8 F$ w
#endif , s+ Y! y* c- h" E
#endif
0 k5 p. H- `+ G* E, C/ @; @4 d5 I' {
" m! Y3 r- V3 R& O9 Tnamespace Stdvcl {class IStrings; class IStringsDisp;} - w0 _& U" @9 S
using namespace Stdvcl;
7 D @; ]& J9 Q/ [
# u5 i' Q4 D( Anamespace Pcomserver_tlb
7 {: C+ f% Q9 U+ i0 h{
; `! _4 k7 b: K* O( VDEFINE_GUID(LIBID_PCOMServer, 0x5BD378E5, 0x4B57, 0x11D3, 0xB8, 0x5B, 0x00, 0xE0, 0x98, 0x04, 0xA4, 0x18);
9 [5 l# H/ l8 M% \DEFINE_GUID(IID_IMyCOM, 0x5BD378E6, 0x4B57, 0x11D3, 0xB8, 0x5B, 0x00, 0xE0, 0x98, 0x04, 0xA4, 0x18); " {& Z$ U; ]0 l$ A
DEFINE_GUID(CLSID_MyCOM, 0x5BD378E8, 0x4B57, 0x11D3, 0xB8, 0x5B, 0x00, 0xE0, 0x98, 0x04, 0xA4, 0x18);
& {9 f( M. t1 Q& F7 ?9 uinterface DECLSPEC_UUID("{5BD378E6-4B57-11D3-B85B-00E09804A418}") IMyCOM; 5 V# y: i+ c J# w3 s: F
typedef IMyCOM MyCOM;
' [8 }# \3 b5 l u
% t( f j$ }4 p: U: }7 K) |#define LIBID_OF_MyCOM (&LIBID_PCOMServer) 4 M3 ?5 N1 x$ z A. a
interface IMyCOM : public IDispatch
9 W: D/ @: a) t v{
. ^7 E& X8 S! I$ Q: {- b8 cpublic:
Z# F/ m! z) u% G2 F1 a virtual HRESULT STDMETHODCALLTYPE AddInt(int x/*[in]*/, int y/*[in]*/, int* ret/*[out,retval]*/) = 0; // [1]
, `3 [* P' ^2 x9 w6 G0 M* h#if !defined(__TLB_NO_INTERFACE_WRAPPERS)
" }0 ^. i2 o7 ~! c int __fastcall AddInt(int x/*[in]*/, int y/*[in]*/)
5 e; V( l2 F7 M9 h* S/ ^ { " H; J; i3 P2 H. w; a, b
int ret;
3 }+ P1 y" _3 b% b% x% J% \ OLECHECK(this->AddInt(x, y, &ret)); % Z" v% E( C/ q! e- Y: n$ g6 a
return ret; ) t2 r7 Z5 H. r9 n0 Y9 j$ J, k8 }* P
} % M( J0 z m/ [8 k9 z
#endif // __TLB_NO_INTERFACE_WRAPPERS
( E/ [8 S" N# w$ C$ ?* A! ~};
5 e/ l# [& N8 ?#if !defined(__TLB_NO_INTERFACE_WRAPPERS)
" e) C7 d6 i; G1 B* x) f0 utemplate <class T /* IMyCOM */ >
1 ^) w$ f( u& I2 n; _& V# \
' c: O, B. \0 q& U8 `class TCOMIMyCOMT : public TComInterface<IMyCOM>, public TComInterfaceBase<IUnknown> ( T9 O5 n O' i) ^, {
{
% r# I1 w4 A! J2 N# w( ?+ y/ mpublic:
8 \5 } R1 G: z: q7 ~7 L5 d TCOMIMyCOMT() {}
; V! ^5 k0 N% d! D) O1 a! _ TCOMIMyCOMT(IMyCOM *intf, bool addRef = false) : TComInterface<IMyCOM>(intf, addRef) {}
% H0 I0 b1 S9 B0 b1 ^' W4 W' b TCOMIMyCOMT(const TCOMIMyCOMT& src) : TComInterface<IMyCOM>(src) {} / Z) Y5 R; M% ?) S6 K+ E5 v0 C* C; Q
TCOMIMyCOMT& operator=(const TCOMIMyCOMT& src) { Bind(src, true); return *this;} 2 W( y1 Y! @3 R0 n, x, C
HRESULT __fastcall AddInt(int x/*[in]*/, int y/*[in]*/, int* ret/*[out,retval]*/);
4 O! G+ W+ T& P. Z: Y: r int __fastcall AddInt(int x/*[in]*/, int y/*[in]*/);
* @4 `( Y3 b% p: m3 q5 [}; ' m( h/ O& Q% B) C& F- q) u
typedef TCOMIMyCOMT<IMyCOM> TCOMIMyCOM; 7 V3 t# w7 F5 D1 K5 b
; Q1 u7 N6 R, D" s! p; Xtemplate<class T>
3 l1 D2 w; S# L( dclass IMyCOMDispT : public TAutoDriver<IMyCOM> 7 c) k$ R. ]( ^' I$ O9 L& p
{ 8 U2 R+ x0 m: S# u6 F& j- q: t5 E) Q
public:
4 }" @1 m3 u" k& p; a( _ IMyCOMDispT(){} 9 u; a4 }6 S4 ^6 [; K
IMyCOMDispT(IMyCOM *pintf)
c3 R# A) Z) v, U: B1 R/ i {
% m8 X9 E# Y. [2 v9 P& q# O( k4 ] TAutoDriver<IMyCOM>::Bind(pintf);
$ q; Q4 O) \( B/ Q# x/ W }
% m& }" A/ s) C0 B* c IMyCOMDispT& operator=(IMyCOM *pintf) 1 G1 m6 x3 P* k0 d
{
0 H0 M% ?1 i# _3 j4 I5 F TAutoDriver<IMyCOM>::Bind(pintf);
* b+ z& E* K* e! `3 w# v5 c return *this;
3 \/ y% ?2 c! Z) q+ \1 I } 7 F% G( j! \! N1 d
HRESULT BindDefault(/*Binds to new instance of CoClass MyCOM*/) Q! y: D8 S" U: Y4 Z8 s& c
{
: T2 S" I' P+ Y. Q2 _- \! y return OLECHECK(Bind(CLSID_MyCOM)); 0 p* |8 M' w- A( q4 z3 n" A% V
} " j+ ]' ~6 V |& q9 B5 i7 C
HRESULT BindRunning(/*Binds to a running instance of CoClass MyCOM*/) 2 k( K0 z D8 r" ~+ _, J3 p
{
4 w, |& e2 _% B( Y. u4 t return BindToActive(CLSID_MyCOM); 6 H( g c! `. c/ M) K) ?
} ' P( _ u" L4 |+ ?5 o
HRESULT __fastcall AddInt(int x/*[in]*/, int y/*[in]*/, int* ret/*[out,retval]*/);
4 M+ k* q9 b0 h$ q int __fastcall AddInt(int x/*[in]*/, int y/*[in]*/); $ X( V# T2 ~1 H. ^7 f8 N+ y
};
( [! K+ v5 P8 Atypedef IMyCOMDispT<IMyCOM> IMyCOMDisp; # M" w' Q2 _7 m$ N# S$ V, i
% E2 B/ H7 ]" j- o# b8 \. ?( M
template <class T> HRESULT __fastcall * i+ }! ]& g2 D0 T
TCOMIMyCOMT<T>::AddInt(int x/*[in]*/, int y/*[in]*/, int* ret/*[out,retval]*/)
9 I5 B6 D/ k2 u6 G# l& d4 r{
' n# s [& w8 g o( ?; l return (*this)->AddInt(x, y, ret); 5 s' m$ D5 |1 E5 P+ n
} . M/ Q+ R! P7 g6 P7 f
. D# G& H, l/ f6 t9 ?( v$ B" M2 ytemplate <class T> int __fastcall
' _. p- X/ V# z! qTCOMIMyCOMT<T>::AddInt(int x/*[in]*/, int y/*[in]*/) # S. |# K3 s, d2 Z
{
5 Q$ f. t( m C* x! d int ret; 4 g8 m& o9 ?! A4 E' j7 O" x
OLECHECK(this->AddInt(x, y, &ret)); ) K9 g: C6 O. S: Y. a- }8 ~
return ret;
) k4 o+ a: K4 k* [- }} 6 ^ Q6 {3 \0 z, J; W, D
# ~3 _6 b1 V$ U+ Ktemplate <class T> HRESULT __fastcall 0 o! z W, [. K6 a( w1 Y9 Z" y
IMyCOMDispT<T>::AddInt(int x/*[in]*/, int y/*[in]*/, int* ret/*[out,retval]*/) ' s" e/ b' r' K( q; M ~5 n
{ 0 ^- D/ I* ^6 y
static _TDispID _dispid(*this, OLETEXT("AddInt"), DISPID(1));
3 V+ a8 m7 n/ y/ `6 i TAutoArgs<2> _args; 9 A/ c6 E+ @) o p6 ]
_args[1] = x /*[VT_INT:0]*/;
/ o/ z0 g7 b6 [* { _args[2] = y /*[VT_INT:0]*/; " B9 F( p5 a2 H5 }' c
return OutRetValSetterPtr(ret /*[VT_INT:1]*/, _args, OleFunction(_dispid, _args)); 4 a9 z1 m7 P& ^5 M( R$ F2 }4 |
}
. X4 o3 z& E: ]. T " h' E$ m) Y8 {" _6 U- s; p
template <class T> int __fastcall ) Z! p; }* @( n/ d
IMyCOMDispT<T>::AddInt(int x/*[in]*/, int y/*[in]*/) - \7 b& P9 _; V, \6 e- ~
{ 8 O$ ]0 u$ g- v; d3 g
int ret;
! A- R9 I2 F2 S7 ~6 o+ O! v this->AddInt(x, y, &ret); 9 i4 U _' I7 [2 A
return ret;
6 P$ u m1 X* Y$ L3 d}
5 ? U! ]/ _' L: }5 g1 V$ Z% x ! f+ K. B1 x- r3 ?: }9 m( R. {
typedef TCoClassCreatorT<TCOMIMyCOM, IMyCOM, &CLSID_MyCOM, &IID_IMyCOM> CoMyCOM; : u) F2 i1 [4 v; h
#endif // __TLB_NO_INTERFACE_WRAPPERS
0 j Y: T/ P9 f" \% a}; // namespace Pcomserver_tlb
/ M& H, a8 h" S1 |$ q4 o7 F#if !defined(NO_IMPLICIT_NAMESPACE_USE) 0 ]; x8 F5 m: b
using namespace Pcomserver_tlb;
: W4 g( P3 T+ D- y1 P& b#endif
) O" P2 d$ B& s#pragma option pop 5 u3 A: ~$ l* y7 \, p/ z/ v
#endif // __PCOMServer_TLB_h__
( q$ }; r1 ?( e下面是文件中说明的主要对象及其定义:
- i) u- q q9 x `4 \interface IMyCOM : public IDispatch
) l) ^& N& r2 _. Eclass TCOMIMyCOMT : public TComInterface<IMyCOM> ( x: J0 p5 y& r* U7 j* M
class IMyCOMDispT : public TAutoDriver<IMyCOM>
- i, X3 L9 y8 j/ T* Yclass CoMyCOM: public CoClassCreator $ x" Q. m7 _& a
◆IMyCOM:通过IDispatch接口来调用对象的方法,该接口可以使对象被不支持虚拟函数表(VTable)的语言(如Visual Basic)说调用。这是一种很慢很苯的接口调用方式。
& b1 e: \$ H& \7 Y: u◆TCOMIMyCOMT:通过所谓的智能接口来调用对象的方法,既可以实现IDispatch调用,也可以采用VTable进行调用,从而实现最快的调用速度。 ( R+ b' k) E9 l6 X
◆IMyCOMDispT:通过disp接口来调用对象的方法,可以提高Idispatch接口的访问速度,但还是比不上VTable接口。 , w- L- U; a4 A8 ]
◆CoMyCOM:通过使用CoClassCreator可以自动产生TCOMIMyCOM代理的实例。
: T* C0 J* \2 p' C' ?9 w3 W 下面介绍一下实现智能接口和Disp接口调用的客户程序。这个客户程序很简单,有两个按钮分别完成两种接口调用的方法,一个编辑框显示结果。
: ]2 ^2 N7 B: V% p* @& e U◆智能接口的VTable调用方法如下: : z; n" s, |& W! n- N4 F. j
int x=6,y=6;
1 `' q V; \6 _. }5 h9 X TCOMIMyCOM O;
9 P9 j! |9 E+ q! k O=CoMyCOM::Create(); //通过CoClassCreator完成初始化 # I8 `0 T* V0 f
O->AddInt(x,y,&y); //Vtable形式调用
7 v; D7 J% |9 |& `) q% E' O' c Edit1->Text=IntToStr(y);
" |% [; E0 T1 b( R◆DISP接口的调用方法如下: / [5 B1 s- ^2 H$ Q+ i1 G8 m
int x=6,y=6;
f& ^+ b6 x4 V/ x- d IMyCOMDisp app;
) S0 P: ?7 r& ~8 I# W app.BindDefault(); //通过Bind完成初始化 $ k p( K: U7 D) q' z D7 p, T+ `
app.AddInt(x,y,&y); //Disp形式调用 . q8 @* c" }2 T) a( o
Edit1->Text=IntToStr(y);
g0 x$ k) j! [4.小结
4 A3 L" F- u, K3 R8 m# _8 Z0 H: e" n 上面的程序举例是很简单的,但却详细说明了COM应用软件的开发过程。COM技术不是一个编程语言,而是一种编程规范和方法。采用COM技术可以开发功能强大的软件,有利于分布式应用技术的实现,有利于多人合作开发,也可以帮助我们理解Windows系统本身。COM的接口技术是比较复杂的,想进一步了解COM技术可参阅清华大学出版社的《COM技术内幕》一书。
; D( D: ~' U; a M C++ Builder是开发COM应用软件的好工具,它隐含了COM实现的细节,我们只需与它打交道就可以开发完善和强大的COM应用程序。希望有更多的人转到COM应用软件的开发上来,COM技术是软件技术未来的发展方向,是实现软件工程中软件即插即用的有效途径。
! ]2 {' t8 z% {2 T! m
4 ?: ]0 O4 c! C& R( n5 u) s8 } |