现在的位置: 首页 > 综合 > 正文

VCL类学习之(一) TBasicAction

2017年12月02日 ⁄ 综合 ⁄ 共 4817字 ⁄ 字号 小 中 大 ⁄ 评论关闭
  学习过设计模式的人都知道有一种行为模式叫做Command模式。在Delphi的VCL Framework中也使用到了这种模式，那就是Action模式。

    命令模式使用的目的在于使用对象来封装客户端的请求命令，由于使用以对象封装，因此可以达到下面的效果：

  • 请求对象可结合多态以及虚拟方法来提供更大的弹性；
  • 负责执行请求的目的对象可以和客户端分离，这就表示多个客户端可以发生相同的请求对象，例如菜单或是工具栏按钮都可以发生打开文件的请求，如此一来菜单和工具栏按钮便可以使用相同的请求对象，而负责打开文件的程序代码并不会绑定到单一的菜单项或是工具栏按钮；
  • 由于使用了请求对象，因此不单是图形用户界面可以触发请求，一般的程序代码也可以通过请求对象来执行特定的工作；
  • 由于请求对象可以使用一个完整的类架构来实现，因此可以让客户端使用一致的程序代码格式来触发各种不同的请求。 

    1. Unit Classes;
    3. { TBasicAction }
    5.   TBasicAction = class(TComponent)
    6.   private
    7.     FActionComponent: TComponent;  {控件变量}
    8.     FOnChange: TNotifyEvent;       {三个事件变量}
    9.     FOnExecute: TNotifyEvent;
    10.     FOnUpdate: TNotifyEvent;
    11.     procedure SetActionComponent(const Value: TComponent);{设置Action控件}
    12.   protected
    13.     FClients: TList;
    14.     procedure Change; virtual;
    15.     procedure SetOnExecute(Value: TNotifyEvent); virtual;{设置Execute事件函数}
    16.     property OnChange: TNotifyEvent read FOnChange write FOnChange;
    17.     procedure Notification(AComponent: TComponent; Operation: TOperation); override;
    18.   public
    19.     constructor Create(AOwner: TComponent); override;
    20.     destructor Destroy; override;
    21.     function HandlesTarget(Target: TObject): Boolean; virtual;
    22.     procedure UpdateTarget(Target: TObject); virtual;
    23.     procedure ExecuteTarget(Target: TObject); virtual;
    24.     function Execute: Boolean; dynamic;  {其中的动态方法Execute可以由TBasicActionLink类或是TBasicActionLink的派生类或是客户端程序代码调用，而该方法则会执行程序员在它的OnExecute事件中编写的事件处理程序。}
    25.     procedure RegisterChanges(Value: TBasicActionLink);
    26.     procedure UnRegisterChanges(Value: TBasicActionLink);
    27.     function Update: Boolean; virtual;
    28.     property ActionComponent: TComponent read FActionComponent write SetActionComponent;
    29.     property OnExecute: TNotifyEvent read FOnExecute write SetOnExecute;
    30.     {Execute事件 属性}
    31.     property OnUpdate: TNotifyEvent read FOnUpdate write FOnUpdate;
    32.   end;
    34. { TBasicAction class reference type }
    36.   TBasicActionClass = class of TBasicAction;

      TBasicActionClass = class of TBasicAction;

  1. { TBasicAction }
  3. constructor TBasicAction.Create(AOwner: TComponent);
  4. begin
  5.   inherited Create(AOwner);
  6.   FClients := TList.Create;
  7. end;
  9. destructor TBasicAction.Destroy;
  10. begin
  11.   inherited Destroy;
  12.   if Assigned(ActionComponent) then
  13.     ActionComponent.RemoveFreeNotification(Self);
  14.   while FClients.Count > 0 do
  15.     UnRegisterChanges(TBasicActionLink(FClients.Last));
  16.   FreeAndNil(FClients);
  17. end;
  19. function TBasicAction.HandlesTarget(Target: TObject): Boolean;
  20. begin
  21.   Result := False;
  22. end;
  24. procedure TBasicAction.ExecuteTarget(Target: TObject);
  25. begin
  26. end;
  28. procedure TBasicAction.Notification(AComponent: TComponent;
  29.   Operation: TOperation);
  30. begin
  31.   inherited Notification(AComponent, Operation);
  32.   if (Operation = opRemove) and (AComponent = ActionComponent) then
  33.     FActionComponent := nil;
  34. end;
  36. procedure TBasicAction.UpdateTarget(Target: TObject);
  37. begin
  38. end;
  40. function TBasicAction.Execute: Boolean;
  41. begin
  42.   if Assigned(FOnExecute) then
  43.   begin
  44.     FOnExecute(Self);
  45.     Result := True;
  46.   end
  47.   else Result := False;
  48. end;
  50. function TBasicAction.Update: Boolean;
  51. begin
  52.   if Assigned(FOnUpdate) then
  53.   begin
  54.     FOnUpdate(Self);
  55.     Result := True;
  56.   end
  57.   else Result := False;
  58. end;
  60. procedure TBasicAction.SetOnExecute(Value: TNotifyEvent);
  61. var
  62.   I: Integer;
  63. begin
  64.   if (TMethod(Value).Code <> TMethod(OnExecute).Code) or
  65.      (TMethod(Value).Data <> TMethod(OnExecute).Data) then
  66.   begin
  67.     for I := 0 to FClients.Count - 1 do
  68.       TBasicActionLink(FClients[I]).SetOnExecute(Value);
  69.     FOnExecute := Value;
  70.     Change;
  71.   end;
  72. end;
  74. procedure TBasicAction.Change;
  75. begin
  76.   if Assigned(FOnChange) then FOnChange(Self);
  77. end;
  79. procedure TBasicAction.RegisterChanges(Value: TBasicActionLink);
  80. begin
  81.   Value.FAction := Self;
  82.   FClients.Add(Value);
  83. end;
  85. procedure TBasicAction.UnRegisterChanges(Value: TBasicActionLink);
  86. var
  87.   I: Integer;
  88. begin
  89.   for I := 0 to FClients.Count - 1 do
  90.     if FClients[I] = Value then
  91.     begin
  92.       Value.FAction := nil;
  93.       FClients.Delete(I);
  94.       Break;
  95.     end;
  96. end;
  98. procedure TBasicAction.SetActionComponent(const Value: TComponent);
  99. begin
  100.   if FActionComponent <> Value then
  101.   begin
  102.     if Assigned(FActionComponent) then
  103.       FActionComponent.RemoveFreeNotification(Self);
  104.     FActionComponent := Value;
  105.     if Assigned(FActionComponent) then
  106.       FActionComponent.FreeNotification(Self);
  107.   end;
  108. end;

对于TBasicAction的派生类而言，例如处理Paste动作的TEditPase类，就可以改写HandlerTarget虚方法，并且在其中编写执行粘贴的程序代码。

  1. TEditPaste = class(TEditAction)
  2.   public
  3.     procedure UpdateTarget(Target: TObject); override;
  4.     procedure ExecuteTarget(Target: TObject); override;
  5.   end;
  7. { TEditPaste }
  8. procedure TEditPaste.ExecuteTarget(Target: TObject);
  9. begin
  10.   GetControl(Target).PasteFromClipboard;
  11. end;
  12. procedure TEditPaste.UpdateTarget(Target: TObject);
  13. begin
  14.   Enabled := Clipboard.HasFormat(CF_TEXT);
  15. end;

 因此，当我们要使用Action设计模式时，可以编写TBasicAction的派生类，并且改写ExecuteTarget虚方法，就像上面提到的TEditPaste类一样。

或是实现企业逻辑程序代码并且把它指定给TBasicAction类的OnExecute事件，然后再调用Execute虚方法。

 我们通过继承TBasicAction类实现了请求对象类，那么如何将客户端与这些请求对象建立关联呢？这里就用到了TBasicActionLink。

 

咱们明天接着说------>

返回
【上篇】
【下篇】

作者:

抱歉!评论已关闭.

返回首页

Copyright © 2013-2018 学步园  保留所有权利.
软文销售 QQ客服：2265327166 点击这里给我发消息（其他合作也可洽谈）
必威体育
必威电竞