Delphi設計模式之單例模式(Singleton Pattern)

aaie_ 2013-04-05

展開全文

Singleton Pattern模式的設計意圖是：保證一個類僅有一個實例，并提供一個訪問他的全局訪問點。
有人已經實現(xiàn)了這個模式，詳見代碼如下：

interface
uses classes,SysUtils;
 
type
  TSingletonList = class(TList);
 
  TSingletonl = class
  public
    constructor Create;virtual;
    destructor Destroy; override;
  protected
    function Lookup(PSingleton: TSingletonl): boolean;
  end;
 
  TChildSingletonl = class(TSingletonl);
 
var
  Glob_Singletonlist: TSingletonList; //使用整體變量
 
implementation
 
constructor TSingletonl.Create;
begin
  if Lookup(self) then
    Abort
  else
    Glob_Singletonlist.Add(self);
end;
 
destructor TSingletonl.Destroy;
begin
  if Lookup(self) then
  begin
    Glob_Singletonlist.Remove(self);
    inherited Destroy;
  end;
end;
 
function TSingletonl.Lookup(PSingleton: TSingletonl): boolean;
var
  i: word;
  plSingleton: TSingletonl;
begin
  result := false;
  if (Glob_Singletonlist = nil) or (Glob_Singletonlist.Count = 0) then
  begin
    Glob_Singletonlist := TSingletonList.Create;
    result := false;
    Exit;
  end;
  for i := 0 to Glob_Singletonlist.Count - 1 do
  begin
    plSingleton := Glob_Singletonlist.Get(i);
    if (plSingleton.ClassName = PSingleton.ClassName) then
      result := true;
  end;
end; 

他的這種方法是建立一個全局列表，通過查看全局列表的方式來實現(xiàn)singleton模式，這種方法除了沒有廣泛性的問題外，就是他的子類無法實現(xiàn)Singleton模式。所以此方法具有一定的局限性。另外一種的方法的實現(xiàn)：

unit Unit4;
 
interface
uses
  SysUtils, Classes;
 
type
  TDSingleton = class(TObject)
  private
    FCount: integer;
  protected
    constructor CreateInstance;
    class function AccessInstance(Request: integer): TDSingleton;
  public
    constructor Create;
    destructor Destroy; override;
    class function Instance: TDSingleton;
    class procedure ReleaseInstance; 
  end;
 
implementation
 
{$J+}
{ TDSingleton }
 
class function TDSingleton.AccessInstance(Request: integer): TDSingleton;
const
  FInstance: TDSingleton = nil;
begin
  case Request of
    0: ;
    1:
      begin
        if not Assigned(FInstance) then
          FInstance := CreateInstance;
      end;
    2: FInstance := nil;
    else
      raise Exception.CreateFmt('Illegal request %d in AccessInstance!', [Request]);
  end;
  result := FInstance;
end;
 
constructor TDSingleton.Create;
begin
  raise Exception.CreateFmt('Access class %s only through Instance!', [ClassName]);
end;
 
constructor TDSingleton.CreateInstance;
begin
  inherited Create;
end;
 
destructor TDSingleton.Destroy;
begin
  if AccessInstance(0) = self then AccessInstance(2);
  inherited Destroy;
end;
 
class function TDSingleton.Instance: TDSingleton;
begin
  result := AccessInstance(1);
end;
 
class procedure TDSingleton.ReleaseInstance;
begin
  AccessInstance(0).Free;
end;
 
End. 

這里使用了指示符{$J+}
$J在Delphi中的解釋是：
The $J directive controls whether typed constants can be modified or not. In the {$J+} state, typed constants can be modified, and are in essence initialized variables. In the {$J-} state, typed constants are truly constant, and any attempt to modify a typed constant causes the compiler to report an error.
Writeable consts refers to the use of a typed const as a variable modifiable at runtime.
【翻譯】$J指示符控制常量類型是否能夠被修改。在{$J+}狀態(tài)，類型常量可以被修改，并且本質上是初始化為變量。在{$J-}狀態(tài)，類型常量是真實的常量，并且任何試圖修改一個類型常量都會引起編譯器報告錯誤。可寫常量參考運行時類型常量當作變量可修改的。
在劉藝《Delphi設計模式》這本書中，也引用了這兩個例子。并分別做了闡述，這兩個例子是從網絡上找到。并做了相應的改寫。當總是感覺Delphi使用此模式有些蹩腳，不像C++那么的舒暢。這是一個好的想法，但至少在Delphi中不是那么的實用。在delphi中，完全可以使用Initialization初始化一個變量，配合Finalization來釋放他。