数学建模社区-数学中国

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

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

蔡倩

) b; E* b( Z1 S- m! P

主题词: COM ActiveX C++ Builder

5 i2 G+ P4 } I- Q. S5 w! _7 `

1.COM技术概述

% y' e' _- {& Y8 @- [

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

) @# E$ i0 l9 q% \

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

5 o1 K) n+ _0 q3 F- `

◆用于创建ActiveX控件。

) [) a% s8 Y1 `3 R7 I

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

( M9 k$ X9 j2 m6 R7 D* f

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

2 r: _8 u- c' @' t5 Q8 X3 O

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

: y# ^+ X% c# x. ?! ^' k& L( X- Z+ K

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

7 _9 c [' z% u$ T) x

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

3 ]# Q6 }' O f5 [1 b. i

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

! }; W3 B1 l( c; @2 t

2.建立COM服务程序

# z- j$ z. C/ C7 g; `7 ^

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

P4 ~" O! h [6 Z; b2 {: K2 g

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

$ }) f L- y: Y% \: J, b9 \

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

. M/ Q% i6 O4 p' d

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

- g+ A( w. o5 E8 u" d1 s7 o, d: a

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

% _7 k! ~& k2 a% K ~, P# y0 N

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

( Q, t6 s; }& J9 P

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

5 Q3 S& f8 S' d% [+ d! N

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

' l' ^ p; y' R: e2 S& |' z" d* \, H

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

1 P; r! \+ x5 G, r# `7 u9 J

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

/ }1 @3 K! N' f

2.2建立COM接口对象

+ @: E# n5 K! Q

* c, ]2 ?. n/ |! Z+ n" v

* p0 \8 d4 D& Z$ h% N6 O7 o

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

- C% p- |+ j s" v/ X

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

+ n, B+ a3 h {. e$ v

; X" f2 c: T$ V: P

% n: z+ b0 f) ], r- n6 U

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

3 ~- k9 ]. J. r+ V; v* Z

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

. J: M) c4 K. L9 _, Y2 {

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

: F4 c9 T4 x, u5 S" B

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

( _) K5 f2 }$ ~8 j/ R6 U' z

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

- D# t2 {/ {! o( t# T- O% v

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

$ q. }' r# S& [+ G; t6 g

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

: {, A$ V+ e7 \2 j4 q. X

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

! j& s' V5 [$ d2 F

[id(0x00000001)]

2 K& G) q5 S X- b: Q3 v3 F! u

/ I3 \: T m |8 X+ E

2 K7 C" G- n$ S% `. ]# b* g

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

# J) T0 |# B$ D# J0 L2 v

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

% G9 _; S( _) @2 M. _

PCOMServer.TLB: 类型库文件;

1 p" Y: U) F; X" I5 W

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

6 [2 i) i% s3 A6 i

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

% u+ W4 [0 _. I; }2 w/ W

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

* G% \+ v, h ^" m8 `5 v

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

3 n1 J$ y$ Y2 s

2.4 实现COM接口中的方法

+ k W- H, }2 C) ~

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

4 T( T& P c( `4 t7 K

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

+ r, ]3 m. X, ~) v0 Y9 ^" ] o \" {

{

% t) z8 G) a9 \: c8 D

*ret=x+y;

( z2 o+ n* C' Y! d

return S_OK;

2 W5 X( t$ q2 S+ a7 Z

}

* G! y6 h/ s9 r8 |. @3 t8 V1 _

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

: P V% M3 }/ f

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

" V* C& r- g7 e w/ v

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

: C% U: k* K5 a: \/ k# T6 S. N7 ^

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

! U+ m2 ] U/ x. j& z/ y6 S: A1 ^

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

6 r2 z8 H. H+ d8 z- e+ Q0 I% V

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

5 @8 p# g9 A, I7 G6 R7 z

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

3 N1 v0 y& z) `9 Q, r* h

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

* Y: K' j7 Z& @/ m( j% A+ \

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

* x0 ~; M3 |4 V4 O0 A2 W4 ^2 w) E' A

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

+ S! B& t4 U7 B( }

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

5 A, o4 x; U( J' p' s

3.建立COM客户程序

. o: R8 Q- q0 B: j! W" _( E

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

+ f4 A5 S+ D. _. u! Y& r

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

6 n6 m6 Z x$ o8 E

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

- i, j6 G! y; D S( j6 ~

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

; a% s* h& X/ F! M6 s6 x: s

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

( c6 W- a4 i2 u1 f

// Helpfile:

% a1 S% V5 Q: d0 R# B/ Q

// DepndLst:

7 B, @7 ~9 D8 Q& O# i! @. b& X/ p

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

& D2 a! h% y) H

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

" f( L: \7 P# p% I( D3 V4 \

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

/ V4 n& A5 D" e6 [1 @8 G7 G1 x

#ifndef __PCOMServer_TLB_h__

' j3 D; }/ A8 }5 f& m

#define __PCOMServer_TLB_h__

, _' `4 r! z7 I# ^+ }! v0 \7 i! U

#pragma option push -b -w-inl

4 b/ [9 V0 B! J5 ^, Q: s

#include <vcl/utilcls.h>

+ ]. s7 N6 x5 M3 Z# H3 m! i

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

( l3 \6 F7 ~7 M% a6 N+ O

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

4 Z2 [! K8 H- a: y' e: p0 K( S2 i

#endif

2 q9 M9 f( U- ]4 l1 Z

o) s" q: F2 h" G& s# p

#include <olectl.h>

& A( t G9 j+ b8 h" U) n7 w

#include <ocidl.h>

# ^4 H% q0 P3 _( W8 u

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

5 W+ Q; ]& G( g7 [

#if !defined(__TLB_NO_EVENT_WRAPPERS)

7 _ ~" `& f2 D' o! I, J% @

#include <atl/atlmod.h>

7 L4 g& s; K$ s7 h3 c0 R% v

#endif

5 m2 N( z+ T; ~

#endif

- U0 x" Q; j! ~; F( N" |& [& t9 k

2 E8 K# F6 j; Y, h6 e2 |

namespace Stdvcl {class IStrings; class IStringsDisp;}

! x6 S+ p8 u; U g+ ?; I( ?; N1 t0 E

using namespace Stdvcl;

' t9 _" u$ R% U) }' n

* d; Z. t5 l# u9 q/ J

namespace Pcomserver_tlb

5 ?" T$ d4 {( E e; y: ]

{

$ P9 t" w& c5 r7 c- O; Z

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

' W4 O+ p2 P7 W# s

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

3 W9 a, W, T4 I/ m s

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

0 H5 H9 v4 y6 b# [* n$ V3 m

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

J0 g7 \( a/ ^% x8 B9 p" p( D

typedef IMyCOM MyCOM;

- k- y p& k% C! K( S

5 h' I+ A2 b# Q3 C- o

#define LIBID_OF_MyCOM (&LIBID_PCOMServer)

2 @2 U1 D% d8 h) e- `

interface IMyCOM : public IDispatch

3 t: ]0 |1 g- x" K0 k

{

) w! J6 T4 e! V. K" C, A

public:

! C- l3 B' B. I( ~" E2 \

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

3 b$ E6 S) l' d" x5 I: l# f- `

#if !defined(__TLB_NO_INTERFACE_WRAPPERS)

8 c9 W0 b* x3 g1 I( G. O- G

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

& b, r [4 n( t

{

& ]" }, u6 q9 J! D

int ret;

; C6 ^% }: X' n4 U# }: _

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

3 G& F$ V' w/ v0 P; ]' r: L! X

return ret;

# y% X$ ]1 @0 y# ~5 G0 c) |$ U

}

! e6 Y% o6 s& Q7 K7 G5 H

#endif // __TLB_NO_INTERFACE_WRAPPERS

K* ~" \- W! ?9 m- @

};

; P4 e7 B; I* E

#if !defined(__TLB_NO_INTERFACE_WRAPPERS)

' I% e" S5 Y( M* Y- j

template <class T /* IMyCOM */ >

0 k/ Z5 \) q0 n1 X h. h

$ E% [) |5 u7 a

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

, z( K& ]9 s$ j

{

$ f) J8 ]5 s o$ j: t% Y/ I; X! x

public:

' F( Z+ e4 F0 B% }; H

TCOMIMyCOMT() {}

# N. d9 R' y4 x$ X6 }/ L6 o

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

6 H0 `- y ~2 d+ J. ^ v, P

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

5 K" k* W) t& @

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

( ?8 s! E& a+ s) K- s' h( X6 J

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

$ D+ A+ Y& ?- ~8 Z! T s/ ?

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

4 ^) I* c6 P% \) P' n7 l7 |+ f

};

- v% \! W' E2 \" H% h2 X Y1 D* J

typedef TCOMIMyCOMT<IMyCOM> TCOMIMyCOM;

) h; R! ^0 v- c: S1 L) \6 [

! G& h5 u8 I& r5 r5 F& K

template<class T>

+ w+ o8 A. r0 \7 u% E3 T

class IMyCOMDispT : public TAutoDriver<IMyCOM>

6 k: {: Y+ n5 f& \

{

, r( c2 M6 Z+ q

public:

! }. r+ D1 h, z+ \5 `9 c

IMyCOMDispT(){}

+ J9 q& h3 h# a* n: V

IMyCOMDispT(IMyCOM *pintf)

# h. i" n2 J7 L

{

" H3 E/ _; j3 V3 q( Y( N) t! d% H: v

TAutoDriver<IMyCOM>::Bind(pintf);

& ^! _8 t% Y7 i

}

% L6 G! N; ~. A

IMyCOMDispT& operator=(IMyCOM *pintf)

3 Y1 r( W; |7 n

{

/ B* P( d$ t( T# G

TAutoDriver<IMyCOM>::Bind(pintf);

% R1 s4 o$ a% _0 u3 o/ k# g

return *this;

k8 ]- N4 ^5 V- d* U

}

7 o! W0 z! L: k6 K; s# S

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

/ U4 u& ~! O; F" {

{

9 z& \9 r1 l+ Y8 d+ f+ f( p

return OLECHECK(Bind(CLSID_MyCOM));

/ |* t, O. k" e) y- E# T [

}

0 f. \* z G" A( p* ?

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

7 W' V, I& ~4 ]+ E

{

8 d2 Y9 i1 @0 `5 _

return BindToActive(CLSID_MyCOM);

# M* F2 l2 D: C; m% Q

}

7 a( ?, h5 M- M' d

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

7 U/ _! Y. R- m3 `9 x

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

; B _1 m% b, U o

};

+ Y6 ? B6 C$ h, u6 u' x

typedef IMyCOMDispT<IMyCOM> IMyCOMDisp;

+ ^) ^" s4 c8 O+ M- N8 r' F

* R y. n: O6 e& z9 I

template <class T> HRESULT __fastcall

6 m, N' S( Q* W1 g* B, N) h

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

4 z& A2 }& w: }

{

9 H/ _% B0 [3 D+ W0 s

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

. }6 N# Q" j0 R( g R( |1 L

}

* }/ f A4 J; c& f; c7 W

/ s- Y% x8 S% W2 {+ ]6 Q; W

template <class T> int __fastcall

2 q+ h! X; V0 J. x# w( u# N

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

) N9 \3 U/ I) T& N8 J- e

{

) h( u' p! U( @+ w+ U: ?

int ret;

0 G& c+ D* T& R& {7 h& v! o

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

. O1 Q5 h3 Q, F4 o4 @

return ret;

, P! O8 r* Y+ N( t' F, I

}

8 U4 b+ p* c) |( M6 K

2 R! B1 ~! `- \

template <class T> HRESULT __fastcall

0 |- e/ @9 }2 j

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

. s) X; p, W* x7 E! E

{

% Y' n9 b& F8 h' R

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

. j, u2 { e9 ~3 w; l2 f& [' u

TAutoArgs<2> _args;

1 }& j. \9 P, c; @& c' n! B

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

" [+ U- U/ K3 E- a+ f! ~( d4 T, U

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

5 Q. w) s6 c3 ?& r& Z4 Y, Z7 l

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

0 i1 o6 T2 D4 Z) g0 O4 _

}

$ s6 V4 x) x. l. ~

/ g3 [ I- v' y; [6 V* s

template <class T> int __fastcall

5 J, b$ i- D) l' F6 u& p

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

. o' f* q% v/ ~7 Z

{

4 ?6 ?6 F+ X5 f& ]/ }

int ret;

* i6 m9 I5 q: e' e$ B

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

& V6 F+ C7 w' _ s+ e

return ret;

4 h5 z9 Q$ ]/ V: Y# E. h+ V' z

}

2 E/ ]% f) j. ?0 Q$ t$ D

& p1 y/ z9 n4 r

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

* } q# I8 f) _& U- E/ ?0 \$ X

#endif // __TLB_NO_INTERFACE_WRAPPERS

# h( ~" J; N7 R, b

}; // namespace Pcomserver_tlb

& b( _; Q, v9 r+ g% E

#if !defined(NO_IMPLICIT_NAMESPACE_USE)

6 B* O3 A4 I% o6 @+ s

using namespace Pcomserver_tlb;

! z+ d/ I. {! h+ Q& }# c; |

#endif

0 ]9 {- [5 c, J

#pragma option pop

) I6 Y4 m6 {8 w9 @

#endif // __PCOMServer_TLB_h__

+ D/ D+ m% x" M* G: E" \

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

~( b2 G# M. T: r2 N4 f

interface IMyCOM : public IDispatch

( G9 W; |6 K" t, Z6 l0 q4 X% Z

class TCOMIMyCOMT : public TComInterface<IMyCOM>

2 {% U/ m: p; R, H# |) s( E2 y

class IMyCOMDispT : public TAutoDriver<IMyCOM>

7 T& @: K: `. H

class CoMyCOM: public CoClassCreator

' R/ }9 E2 X& b9 q. f- c

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

) g, X8 m, w$ j) @; H. G

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

/ b2 x1 Q2 S# [6 `

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

+ Q9 k. z! A" ^: [

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

2 h7 ?; {8 M3 e$ I4 T# H$ {' L

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

, e# f! ~ x9 ]4 [5 C6 k a

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

" I" I' w$ `+ a& H$ s) k5 h/ \

int x=6,y=6;

; q. x9 E; C, L8 t+ w$ l2 r! L' d; J

TCOMIMyCOM O;

5 i* c; ]' c/ e. D6 P+ j

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

2 n2 X- V _9 ~8 D5 L8 U' C

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

[) S5 Q2 v& i( B+ d

Edit1->Text=IntToStr(y);

( `% E% N1 x( `- \

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

1 ~0 y0 U: ?: y$ {' [4 G% k' d! D

int x=6,y=6;

. U' i5 q8 |' ?2 s4 _; m6 w9 n- T

IMyCOMDisp app;

9 ~$ u# C# [+ u4 y4 b6 S

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

4 \; X4 u! W, r% e" R

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

. G+ r# W& g. I: w& @% H, ^8 i O

Edit1->Text=IntToStr(y);

* H& c E* P$ _1 v8 V9 T

4.小结

/ V0 |: v, L8 g/ H* A

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

6 O' I& ^( O- e0 R* P

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

7 I/ R! x' K6 c* X% a1 G5 H

$ v8 K4 G/ L2 E






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