http://sergworks.wordpress.com/2011/12/08/why-we-need-interfaces-in-delphi/

Why we need interfaces in Delphi.

Posted on December 8, 2011 by Serg

Objects are normally accessed by an object reference.

Interface reference is a different method to access an object’s functionality.

A simple question – why do we need interface references at all, why can’t we use object references everywhere?

There are several reasons to use interface references instead of object references,

but most important of them (at least historically) is accessing an object created in a different program module.

Let us consider a simple example – an object is created in .dll module and consumed in .exe module.

The TMathObject class implements Square and Cube functions on the FOperandfield;

we start with the following naive code:

unit MathUnit;

interface

type
TMathObject = class
private
FOperand: Double;
public
function Square: Double;
function Cube: Double;
property Operand: Double read FOperand write FOperand;
end; implementation function TMathObject.Square: Double;
begin
Result:= Sqr(FOperand);
end; function TMathObject.Cube: Double;
begin
Result:= Sqr(FOperand) * FOperand;
end; end.

We want to create and destroy TMathObject instances in dll module:

library MathDll;

uses
MathUnit in 'MathUnit.pas'; function CreateObject: TMathObject;
begin
Result:= TMathObject.Create;
end; procedure FreeObject(Obj: TMathObject);
begin
Obj.Free;
end; exports
CreateObject, FreeObject; {$R *.res} begin
end.

and use an instance of TMathObject in exe module:

program MathTest;

{$APPTYPE CONSOLE}

uses
MathUnit in 'MathUnit.pas'; function CreateObject: TMathObject; external 'MathDll.dll';
procedure FreeObject(Obj: TMathObject); external 'MathDll.dll'; var
MathObj: TMathObject; begin
MathObj:= CreateObject;
MathObj.Operand:= ;
Writeln('Square = ', MathObj.Square::, '; Cube = ', MathObj.Cube::);
FreeObject(MathObj);
Write('Press ''Enter'' key ... ');
Readln;
end.

If you compile the above example you can see it works, but TMathObject implementation (MathUnit.pas) is duplicated

in both program modules (MathTest.exe and MathDll.dll), and that is not just a waste of program memory.

One of the main reasons to split a program into program modules is a possibility to modify the modules separately;

for example to modify and deploy a different .dll version while keeping an .exe module intact.

In the above example the implementation of TMathObject is a contract that both sides (exe and dll) should adhere,

so the implementation of TMathObject can’t be changed in dll module only.

We need a different form of contract that does not include an object’s implementation.

A possible solution is to introduce a base class containing virtual abstract methods only:

unit BaseMath;

interface

type
TBaseMathObject = class
protected
function GetOperand: Double; virtual; abstract;
procedure SetOperand(const Value: Double); virtual; abstract;
public
function Square: Double; virtual; abstract;
function Cube: Double; virtual; abstract;
property Operand: Double read GetOperand write SetOperand;
end; implementation end.
Note that we can’t access FOperand field directly now because it is a part of TMathObject implementation that should be hidden in .dll module,
so we introduce getter (GetOperand) and setter (SetOperand) virtual methods.
Now we inherit a class that implements virtual methods from TBaseMathObject.
unit MathUnit;

interface

uses BaseMath;

type
TMathObject = class(TBaseMathObject)
private
FOperand: Double;
protected
function GetOperand: Double; override;
procedure SetOperand(const Value: Double); override;
public
function Square: Double; override;
function Cube: Double; override;
end; implementation function TMathObject.GetOperand: Double;
begin
Result:= FOperand;
end; procedure TMathObject.SetOperand(const Value: Double);
begin
FOperand:= Value;
end; function TMathObject.Square: Double;
begin
Result:= Sqr(FOperand);
end; function TMathObject.Cube: Double;
begin
Result:= Sqr(FOperand) * FOperand;
end; end.

The library module source code now is

library MathDll;

uses
BaseMath in 'BaseMath.pas',
MathUnit in 'MathUnit.pas'; function CreateObject: TBaseMathObject;
begin
Result:= TMathObject.Create;
end; procedure FreeObject(Obj: TBaseMathObject);
begin
Obj.Free;
end; exports
CreateObject, FreeObject; {$R *.res} begin
end.
The executable module source code is
program MathTest;

{$APPTYPE CONSOLE}

uses
BaseMath in 'BaseMath.pas'; function CreateObject: TBaseMathObject; external 'MathDll.dll';
procedure FreeObject(Obj: TBaseMathObject); external 'MathDll.dll'; var
MathObj: TBaseMathObject; begin
MathObj:= CreateObject;
MathObj.Operand:= ;
Writeln('Square = ', MathObj.Square::, '; Cube = ', MathObj.Cube::);
FreeObject(MathObj);
Write('Press ''Enter'' key ... ');
Readln;
end.

We can see that MathTest project does not contain MathUnit.pas unit, and is not dependent on TMathObject implementation;

in fact MathTest project does not know that TMathObject class even exist.

We can change TMathObjectimplementation in dll module as much as we want provided that we keepTBaseMathObject intact,

inherit TMathObject from TBaseMathObject and override TBaseMathObject‘s virtual abstract methods.

We implemented a general concept of interface in the form of pure abstract class.

Pure abstract classes are a way how interfaces are implemented in C++ .

This approach has a limited value in Delphi because Delphi does not support multiple inheritance,

and a Delphi class can have only one contract in the form of base abstract class.

Another problem is a limited use of ‘is’ and ‘as’ operators for an object created in a different program module:

Starting from version 3 Delphi introduces a concept of interface that is different from a pure abstract class

and solves the problems with object’s export by using interface references instead of object references:

unit BaseMath;

interface

type
IBaseMath = interface
['{92E9AFF4-25B7-41BD-9EB6-557D12F98BE6}']
function GetOperand: Double;
procedure SetOperand(const Value: Double);
function Square: Double;
function Cube: Double;
property Operand: Double read GetOperand write SetOperand;
end; implementation end.

There is no need to inherit TMathObject class from a given base class now;

we can inherit TMathObject class from any class we like.

Since all Delphi interfaces are descendants of IUnknown (also nicknamed as IInterface in Delphi)

we should also implement the methods of IUnknown interface in TMathObject class.

Delphi provides a helper TInterfacedObject class that already implements the methods of IUnknown

and can be used as TMathObject ancestor:

unit MathUnit;

interface

uses BaseMath;

type
TMathObject = class(TInterfacedObject, IBaseMath)
private
FOperand: Double;
protected
function GetOperand: Double;
procedure SetOperand(const Value: Double);
public
function Square: Double;
function Cube: Double;
end; implementation function TMathObject.GetOperand: Double;
begin
Result:= FOperand;
end; procedure TMathObject.SetOperand(const Value: Double);
begin
FOperand:= Value;
end; function TMathObject.Square: Double;
begin
Result:= Sqr(FOperand);
end; function TMathObject.Cube: Double;
begin
Result:= Sqr(FOperand) * FOperand;
end; end.

There is no need for FreeObject procedure now.

The FreeObject procedure was introduced in the previous examples

to enforce that a TMathObject instance is destroyed

in the same program module where it was created (i.e. in .dll module).

It is always a good rule of thumb that the one who creates an object is the one who destroys it.

But now there is no need to enforce it – if we use interface references object instances

are automatically destroyed in the same program module where they were created.

library MathDll;

uses
BaseMath in 'BaseMath.pas',
MathUnit in 'MathUnit.pas'; function CreateObject: IBaseMath;
begin
Result:= TMathObject.Create;
end; exports
CreateObject; {$R *.res} begin
end.

In the next example a TMathObject object instance is destroyed by assigning nil value to MathObj interface reference.

In most cases there is no need for doing it because an object is

destroyed automatically when all interface references goes out of scope.

In the following code the MathObj interface reference is a global variable and never goes out of scope,

so assigning it to nil explicitly makes sense:

program MathTest;

{$APPTYPE CONSOLE}

uses
BaseMath in 'BaseMath.pas'; function CreateObject: IBaseMath; external 'MathDll.dll'; var
MathObj: IBaseMath; begin
MathObj:= CreateObject;
MathObj.Operand:= ;
Writeln('Square = ', MathObj.Square::, '; Cube = ', MathObj.Cube::);
MathObj:= nil;
Write('Press ''Enter'' key ... ');
Readln;
end.

The interfaced demo works fine, but when I try to load/unload the DLL dinamically,

an access violation is raised at the end of the program in the System unit at the _IntfClear function.

program MathTest;

{$APPTYPE CONSOLE}

uses
Windows,
BaseMath in ‘BaseMath.pas'; //function CreateObject: IBaseMath; external ‘MathDll.dll'; type TCreateObject = function: IBaseMath; stdcall; var CreateObject: TCreateObject;
MathObj: IBaseMath;
Dll: THandle; begin
Dll := LoadLibrary(‘MathDll.dll’);
CreateObject := GetProcAddress(Dll, ‘CreateObject’); MathObj:= CreateObject;
MathObj.Operand:= ;
Writeln(‘Square = ‘, MathObj.Square::, ‘; Cube = ‘, MathObj.Cube::);
MathObj:= nil; FreeLibrary(Dll); Write(‘Press ”Enter” key … ‘);
Readln;
// Access Violation is raised here
end.

Sorry. It was a calling convention problem.
TCreateObject = function: IBaseMath;
works fine.

Great articles.

Great Approach of explanation.

I read a lot about interfaces, but this articles make you understand EXACTLY what is an Interface.

The three examples is the best way to progressively move from one concept to the other.

Thank you very much for your efforts.

Why we need interfaces in Delphi的更多相关文章

  1. Delphi Interfaces

    http://www.delphibasics.co.uk/Article.asp?Name=Interface The reason for interfaces   Classes that ex ...

  2. [Delphi] Delphi版本号对照

    VER300    Delphi Seattle / C++Builder Seattle    23    230    (Delphi:Win32/Win64/OSX/iOS32/iOS64/An ...

  3. Delphi的分配及释放---New/Dispose, GetMem/FreeMem及其它函数的区别与相同

    转载自:http://www.cnblogs.com/qiusl/p/4028437.html?utm_source=tuicool 我估摸着内存分配+释放是个基础的函数,有些人可能没注意此类函数或细 ...

  4. Delphi开发的IP地址修改工具

    用Delphi进行开发的,直接修改注册表,需重启电脑后才生效

  5. Delphi XE5教程3:实例程序

    内容源自Delphi XE5 UPDATE 2官方帮助<Delphi Reference>,本人水平有限,欢迎各位高人修正相关错误! 也欢迎各位加入到Delphi学习资料汉化中来,有兴趣者 ...

  6. delphi 保存网页MHT

    delphi 保存网页MHT   uses ADODB_TLB, CDO_TLB, ComObj,MSHTML;{$R *.dfm}{能把网页如 WWW.QQ.COM保存为一个单文件 .MHT但不能把 ...

  7. Delphi GDI+ Library

    GDI+ LibraryThis library enables GDI+ functionality for Delphi 2009 and later. It differs from other ...

  8. Delphi实现HTMLWebBrowser实现HTML界面

    HTML的界面有以下特点:图文混排,格式灵活,可以包含Flash.声音和视频等,实现图文声像的多媒体界面,而且易于建立和维护.另外,HTML的显示环境一般机器上都具备,通常不需要安装额外的软件.当然, ...

  9. [转]Delphi I/O Errors

    The following are the Windows API (and former DOS) IO errors, which are also the IO errors often ret ...

随机推荐

  1. Shell教程2-变量

    Shell支持自定义变量. 定义变量 定义变量时,变量名不加美元符号($),如: 复制纯文本新窗口   variableName="value" 注意,变量名和等号之间不能有空格, ...

  2. Arduino报错

    avrdude: stk500_recv(): programmer is not respondingavrdude: stk500_getsync() attempt 1 of 10: not i ...

  3. Drupal 7.23:函数drupal_alter()注释

    /** * Passes alterable variables to specific hook_TYPE_alter() implementations. * * This dispatch fu ...

  4. OTG_FS_ID功能及引申

    1. 概要   OTG设备使用插头中的ID引脚来区分A/B Device,ID接地被称作为A-Device,充当USB Host,A-Device始终为总线   提供电力,ID悬空被称作为B-Devi ...

  5. 【LeetCode】38 - Count and Say

    The count-and-say sequence is the sequence of integers beginning as follows:1, 11, 21, 1211, 111221, ...

  6. Python中list的实现

    原文链接这篇文章介绍了Python中list是如何实现的.在Python中list特别有用.让我们来看下list的内部是如何实现的.来看下面简单的程序,在list中添加一些整数并将他们打印出来. &g ...

  7. hadoop2.6.0 --- 64位源代码

    今天有朋友在群里找hadoop最新的2.6.0的源代码,其实这个源代码在hadoop的官方网站是有下载的(应该是32位的),还有一个src,不过给的是maven版本,需要自己在机器上编译一下(我的机器 ...

  8. Web 检测代码 web analysis 开源 open source

    1. Grape Web Statistics Grape Web Statistics is a fairly simple piece of analytics software. Grape i ...

  9. android 源码 中修改系统字体大小

    在源码\android\frameworks\base\core\java\android\content\res \Configuration.java下有读取DEFAULT_FONTSCALE的值 ...

  10. EasyUI DataGrid 窗口大小自适用--------------未测试

    EasyUI 新版本里添加了 fit 属性,不需要老版本的那么复杂,重新load DataGrid.但是昨天用的时间发现只有一个DataGrid的时候用fit:true 很好使,但是如果有其它元素,如 ...