数学建模社区-数学中国

标题: COM应用软件开发技术 [打印本页]

作者: 韩冰    时间: 2005-1-26 01:07
标题: COM应用软件开发技术

蔡倩

" ?! u& K/ q2 Y' F

主题词: COM ActiveX C++ Builder

1 H" t0 G/ ?9 L5 f8 d' q, X9 B

1.COM技术概述

- z& b' J! U# b/ c0 c# ^

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

6 B1 p2 b/ t" y) y

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

9 C+ q$ D9 v& f. V1 K( f4 _1 g% |' U

◆用于创建ActiveX控件。

9 T0 v& g6 Z9 i1 p2 g) c. J+ F

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

1 a: p; c5 V" ]+ X/ _9 `

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

$ A# t E$ ]$ R5 J

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

+ ?4 t8 s5 b2 D$ d: W* t. b

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

) f5 k6 N+ M* z, `7 }( V7 ?

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

. d2 ]6 O4 e) S

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

$ A( n$ I( Y6 j

2.建立COM服务程序

K+ z' \, {# m$ c0 h) @

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

+ z* Z$ j" Q; Q

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

$ E% z; o* G1 e; c+ q8 Z% F

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

7 ~6 U* z s, C, @& A. E

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

4 E3 G7 F. g/ G' I3 `; U) ]: }

◆打开File/New/ActiveX项目页,选择ActiveX Library;

, K) n; o, U/ m; b2 T0 x" F7 t

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

( [ T2 Q2 O3 K

PCOMServer.bpr:工程的项目文件;

: {- h2 Z9 s% P! B& {

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

. y0 `& U. G" G

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

5 ~. [/ x6 H" u* x" w" P- y

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

1 g! Y- F2 |# M" V% q9 [

2.2建立COM接口对象

7 G! b0 {, @ t

8 g6 m k) c: C N2 S6 e3 J

( w ?% F) v. P$ m. c

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

) `. x- ~2 [) [5 [* R& x

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

( C/ ~5 H, H) d, U: N( L

9 s* k! [" T/ }

, M0 _3 q# o8 o- E

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

* I$ S4 T" z$ U9 I4 O

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

; L! |3 O2 x0 P7 _( [9 K$ I, \8 n

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

: y+ b- g$ N$ W" \) G$ J V9 e

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

i6 d! ~' |9 w6 ]+ L

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

. ]5 p4 x1 D# `) ~/ c; T4 r

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

$ Q$ v5 g0 o0 H

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

/ N% d3 Y6 ]1 E' f

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

4 @; {- q2 p+ p# F

[id(0x00000001)]

% d o5 H7 \: M$ B9 Q- X* |

?! j, N9 L0 o. e

" V; I1 `- i: x% |5 x

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

- M8 w/ T2 V. N5 ~8 X

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

+ i& E' b# A: E' }4 q( C

PCOMServer.TLB: 类型库文件;

. C; l4 e4 y; P1 u9 J

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

8 L5 \3 e/ U! {0 O8 Q h9 `9 z

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

: Q8 C0 g: g4 o0 j, y/ Z6 R$ Q

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

9 G- h0 A5 j7 q( N% m

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

7 s! }9 Y5 z$ t. m. Q

2.4 实现COM接口中的方法

. n n4 ~3 C' j! w

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

7 Q0 {- h' x( K7 x

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

+ o, g% M5 y+ h6 H: P

{

/ U7 {- O. Y4 _0 W4 a

*ret=x+y;

! S2 i \0 _: o0 C; [9 m

return S_OK;

6 M9 i8 n) |) Y- I3 o5 H6 I

}

" i6 R; J9 ~; n% g: ^' x- o

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

+ O- }! G$ ^/ L5 g% ]

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

+ Z' Q/ [8 b) l4 O) y

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

& S, j7 k+ t+ [

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

. ^+ M+ x' v) C% e" Z' ?* Q

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

H6 S! u$ F) }- l

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

9 ]9 V3 s5 [! K p; _6 k

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

4 O+ G/ d$ x% S* O# P* N4 }1 L

InprocServer32:存储PCOMServer.DLL的路径目录;

$ u. z! a R9 d9 g" B

ProgID:存储COM对象的注册名:PCOMServer.MyCOM;

; j5 _! v! ]! a1 I- b

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

+ j) B. `) E- V; n' K. F( d, y

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

; b: w* D% z+ |' y6 {

3.建立COM客户程序

. L$ l z- k+ F9 g" ~" n6 J

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

5 ` c0 M! i0 Y: s! d

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

1 B, U4 e0 v- S

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

. A$ D0 P- o) X$ J" |0 Z

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

% q% Q \& L0 g

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

" J% F: j+ G* E- ]& K

// Helpfile:

# K) b$ A$ V b G3 W, x

// DepndLst:

- S6 g# B# D; z; z( p3 `

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

. R, M2 e6 Y6 M$ R5 U

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

- M2 h) g$ G/ a- U6 d2 i2 q

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

- k* e( u, p, @8 e# I d) X+ o

#ifndef __PCOMServer_TLB_h__

7 ?+ \) H% u6 x2 t

#define __PCOMServer_TLB_h__

4 F& G! A$ L* A! J, D( [& V

#pragma option push -b -w-inl

5 l9 M3 L3 U% g: c2 u5 F; }3 ~, m7 q

#include <vcl/utilcls.h>

' ^ G$ h) U& P0 V

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

2 P' J, J& K% o! |% q- ], N2 k

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

3 A" O4 @; l7 r. ~& {# R

#endif

( B7 \& V% {: S9 E; v' ?

# H' R. o$ p5 R- x! T5 x- _; R1 R

#include <olectl.h>

! X' ?) }$ H% m9 P: I/ K

#include <ocidl.h>

" X* Y- N* _; f! h2 A' x0 ?) J

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

* Q9 t- q* E3 h$ ?

#if !defined(__TLB_NO_EVENT_WRAPPERS)

" Y* y7 r: W$ e" L

#include <atl/atlmod.h>

' d1 I/ u/ c" e R

#endif

, b1 Q# R8 S9 T L& C) ~# R

#endif

4 _3 N0 P8 E$ I) l

# _8 ]" L7 M- G* B( q, i. G" x

namespace Stdvcl {class IStrings; class IStringsDisp;}

# @( n( u4 l/ X+ o1 S

using namespace Stdvcl;

% C" C7 S. J0 K

2 I, |9 F8 t- I% f0 \+ Y

namespace Pcomserver_tlb

+ V5 ]' I/ B, C* `6 b8 F4 l

{

6 o0 K6 T3 K, H% a6 q

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

8 ~0 X0 S; h# ]- u" \9 Q+ p" h

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

' r- l5 ?0 W9 ^4 ^# F/ P3 V' o

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

* e( {1 x2 G/ @+ {9 `, f+ D

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

0 d3 t, J$ O- e7 }5 j

typedef IMyCOM MyCOM;

1 W# F6 @7 h* Z8 c; s. m6 E

( z& N3 O s# _1 ]+ N

#define LIBID_OF_MyCOM (&LIBID_PCOMServer)

+ I5 j9 e+ L8 l$ Q) O7 x4 X

interface IMyCOM : public IDispatch

; J. y3 A; ?2 n& W

{

" r# \/ q( h! t, S% x0 L

public:

6 Q( _' ]0 S) f9 a7 q/ `9 f9 l

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

; L) P2 b9 _% ~% i# l3 @

#if !defined(__TLB_NO_INTERFACE_WRAPPERS)

$ ?1 f+ F: N/ z

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

& b3 Z; ]" v* W5 U

{

/ G) {& ^' L* f

int ret;

& n, O L" T+ M* r7 L, X' ^* k

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

# L. w4 m) @3 G* N6 u

return ret;

# k% i+ z9 r6 g+ K9 z& B

}

- J5 B% e- y, z4 @6 n% o0 H

#endif // __TLB_NO_INTERFACE_WRAPPERS

) V% O0 H. G3 O' q0 M

};

4 f: c! j9 x2 [% x

#if !defined(__TLB_NO_INTERFACE_WRAPPERS)

, F' E6 w, A/ s/ k1 l+ u, @

template <class T /* IMyCOM */ >

. }0 A+ S8 G9 L( H' ^- _7 h

2 C; V n% J0 Q$ t! a. L

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

$ _$ u$ J h( a |; U" R3 u3 w

{

( I8 A9 j& i, T% [# y

public:

% X9 J, o% c8 Q+ M6 U1 p

TCOMIMyCOMT() {}

7 A3 u7 B1 ]7 K8 }: O- K

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

2 B' w( \# T @: ^" G% b/ c5 v

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

- Y% O& Q" p0 [$ R) O2 N; S$ i

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

+ w# f: a# x% m2 F% X* B

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

, f4 P" i& ~, T9 W* ^

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

. I }3 C5 d& |" V

};

. x$ U' ]2 `, c' f

typedef TCOMIMyCOMT<IMyCOM> TCOMIMyCOM;

" F! F# o* J, L: l

9 Z5 z% J! P" d7 n0 i& C% j [

template<class T>

% O' _1 }* ]0 y8 L/ \9 D2 |

class IMyCOMDispT : public TAutoDriver<IMyCOM>

: J# d V0 n! [2 N9 O

{

( v, [+ e# @# J

public:

4 s0 j p- J! Z" B: C. p: a1 Z

IMyCOMDispT(){}

1 E1 a: P3 {. u+ d

IMyCOMDispT(IMyCOM *pintf)

! E* h: Y1 I2 o* A+ M

{

+ ~0 p2 t% F! v% ^, }; b& ^% x

TAutoDriver<IMyCOM>::Bind(pintf);

. D) x2 @/ d/ r- c

}

# o7 ?' Z) `- R2 ^

IMyCOMDispT& operator=(IMyCOM *pintf)

. Z( Z# E8 O7 S {2 {& Z! r

{

" \% Y0 U8 T: j$ n/ K

TAutoDriver<IMyCOM>::Bind(pintf);

, R- _8 d1 z- f) K

return *this;

; ^$ u" V0 m% `3 i$ m

}

Y4 _) U. |, G! c

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

! ?$ g$ `$ V& z$ A; `; Q

{

& W/ r; o. m& h1 C7 n

return OLECHECK(Bind(CLSID_MyCOM));

* C" x- X; s& N6 X

}

/ x- b9 L8 d/ t$ h6 D5 s4 f% f* \

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

; d2 k7 a8 p8 j) Y/ f

{

& ^; b, H ]9 C0 e* m$ }7 u4 J

return BindToActive(CLSID_MyCOM);

0 T/ @0 E9 I% `& v! K! h3 E: A0 A

}

# m& H: m) `3 F

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

, z" C% K( i1 W6 O

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

( G/ N* S2 `! _3 Q

};

1 f/ j5 I2 b0 u5 w% K- H8 }# B

typedef IMyCOMDispT<IMyCOM> IMyCOMDisp;

. h4 m: t6 k( Z! B o

3 \0 W6 V5 {1 e4 v+ Z4 ?

template <class T> HRESULT __fastcall

/ {2 W& m; W; t

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

# P; v' w0 \9 e$ s+ S* C5 W8 b' L" q

{

. T9 S5 e) ~6 ]0 }8 w( L

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

q5 F! \4 v' f9 [# }, t+ i5 T

}

4 s! s/ Q+ F0 Y) ]4 w7 m& G

( y0 p+ F7 j' \2 `9 A8 G8 z% A

template <class T> int __fastcall

* _; R9 r# k& O _1 M ]- Y6 ]

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

9 U. M+ N$ h9 `0 y, Z0 t

{

/ [/ w$ ]. @4 P, R$ U

int ret;

# u1 N( J" k4 J% i; Y9 w

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

% L/ j2 P- J% f1 z7 l1 l* v$ z

return ret;

9 J* d C7 E1 o, i4 Q- W

}

" n6 h7 `% v: s _

$ }) E0 h6 |3 W2 }4 f& P. o! O

template <class T> HRESULT __fastcall

# q" g$ T4 Y2 J# J" D, P6 h

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

/ b' m4 h* t8 X# c

{

- C2 t4 a5 W5 A' `2 b- e, Q

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

- u$ Z( ^! y' R8 W! W

TAutoArgs<2> _args;

/ x9 t+ \1 b" |2 o) t

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

5 ]4 F; a2 N2 ?+ v8 r

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

- O0 M" ?2 }3 h5 b! g9 l, S

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

: \! k6 |# \& {: e( F( P

}

+ g k" L3 A7 l: E9 y

% `2 z) _9 V# o# U9 ^

template <class T> int __fastcall

, \% }& X- f# r. F' E) v

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

) w! i% ?# q3 o" T: \

{

- b3 `& J/ V* e W* c# w) L

int ret;

+ B1 v, W9 G" k3 i B2 V- R+ [

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

+ p0 [' Q$ P4 x2 I. P

return ret;

+ ~4 H/ E9 S# c5 X5 E0 R: ]5 Q

}

5 ]: M% o ~( n- y) H( l, ^- R

9 [7 g( A) |* ~4 M8 x' W: x! D

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

, O e& j* \2 ?+ m. R

#endif // __TLB_NO_INTERFACE_WRAPPERS

( M0 y5 Y3 V$ L$ r8 x2 d

}; // namespace Pcomserver_tlb

: P9 q) c! e2 S* Q) e" G

#if !defined(NO_IMPLICIT_NAMESPACE_USE)

* ~' @$ \, u5 x0 A; |7 u

using namespace Pcomserver_tlb;

0 R+ D/ u ]# s6 J' t1 d

#endif

; z+ W+ J9 l" N; V/ o i, X

#pragma option pop

( G( | V# W& A3 n

#endif // __PCOMServer_TLB_h__

A8 x' q9 z$ |" |9 H! t

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

; C2 I; r- @& T) d% i

interface IMyCOM : public IDispatch

) X$ s& J j3 H

class TCOMIMyCOMT : public TComInterface<IMyCOM>

3 Z' `( B x N

class IMyCOMDispT : public TAutoDriver<IMyCOM>

1 Q: U0 [2 }+ c# A( k# L

class CoMyCOM: public CoClassCreator

, ]8 {2 w& A/ t5 b# \5 p

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

4 j2 \* e) Y. u( _& N7 F

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

( O- G2 l5 l; O

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

5 b6 G+ ]# n: k$ Q$ V! M

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

, W, i& |8 r6 K- |7 d$ D* F7 S& B+ O+ b

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

7 F- a8 ?0 T6 l5 {1 P W0 c. R

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

& X" @0 c2 C7 v9 U. A) y

int x=6,y=6;

7 ?2 i' [9 U6 @

TCOMIMyCOM O;

0 F, e# o/ K& v/ |. }4 b

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

^9 c4 T) A- W

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

2 `' n( D8 W+ Q) m( P

Edit1->Text=IntToStr(y);

* J" \0 `/ q' K, c* J4 W( g$ L

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

, _0 y+ C2 P6 K& w: a: ] o% o1 J" H

int x=6,y=6;

}( W `+ F8 C* ~; ]8 f

IMyCOMDisp app;

" Y4 \' L* [! [& _

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

5 e' L6 x6 d* B* W

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

: q. q% w* S6 M1 |" b0 `

Edit1->Text=IntToStr(y);

2 w- \9 c6 t/ r) v, c0 r

4.小结

9 P3 B' `* {5 n3 v

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

% [* | a# n4 s5 Q+ m0 }; p

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

" |" f" ?- u7 S

0 t+ b% U% q( o) l1 v






欢迎光临 数学建模社区-数学中国 (http://www.madio.net/) Powered by Discuz! X2.5