Thứ Tư, 26 tháng 9, 2012

Interpreter pattern

Interpreter Pattern : Người phiên dịch



Interpreter Pattern giúp người lập trình có thể "xây dựng" những đối tượng "động" bằng cách đọc mô tả về đối tượng (file XML hoặc gì đó) rồi sau đó "xây dựng" đối tượng đúng theo mô tả đó.

Metadata (ngôn ngữ mô tả) --> [Interpreter Pattern] --> Đối tượng tương ứng.


Mẫu gồm 2 thành phần chính có liên hệ với nhau là Context Expression
  • Context chính là phần chứa thông tin biểu diễn mẫu chúng ta cần xây dựng
  • Expression là phần chứa các phép logic để đưa thông tin của context thành đối tượng cụ thể


Ví dụ 1: Biểu mẫu của ngày thay đổi dựa trên từng loại thể hiện (Ví dụ dd/mm/yy hay dd/mm/yy - hh:mm:ss). Giải quyết vấn đề làm sao xuất ra biểu mẫu đúng với từng loại thể hiện

Phương pháp thông thường : Dùng các câu lệnh rẽ nhánh if .... then ... else

 if(IsWordDate)  
 {  
      formattedDate = date.DayOfYear + "th day, " +  
      date.DayOfWeek + ", " +  
      ConvertMonth(date.Month) + " " +  
      ConvertDay(date.Day) + ", " +  
      date.Year;  
 }  
 else if (IsCalendarDate)  
 {  
      formattedDate = date.Month + "-" +  
      date.Day + "-" +  
      date.Year;  
 }  
 else if (IsGregorianDate)  
 {  
      formattedDate = date.Month + "-" +  
      date.Day + "-" + date.Year + " " +  
      date.Hour + ":" + date.Minute + ":" +  
      date.Millisecond;  
 }  
   

Giải pháp : Sử dụng mẫu Interpreter và các Expression Engine để quản lý sự khác nhau giữa các mẫu ngày bằng Expression Type.

Cài đặt theo mô hình:

   
 // Context  
 Class Context  
 {  
      private string _formattedDate;  
      private DateTime _date;  
        
      public Context(DateTime dateToFormat)  
      {  
           _date = dateToFormat;  
      }  
        
      public DateTime Date  
      {  
           get{return _date;}  
      }  
        
      public string FormattedDate  
      {  
           get{return _formattedDate;}  
           set{_formattedDate = value;}  
      }  
 }  
   


 //Interpreters  
 abstract class AbstractDateExpression  
 {  
      public abstract void Interpret(Context context);  
 }  


   
 class WordDateExpression : AbstractDateExpression  
 {  
      public override void Interpret(Context context)  
      {  
           context.FormattedDate = date.DayOfYear + "th day, " +  
           date.DayOfWeek + ", " +  
           ConvertMonth(date.Month) + " " +  
           ConvertDay(date.Day) + ", " +  
           date.Year;  
      }  
 }  


   
 class CalendarDateExpression : AbstractDateExpression  
 {  
      public override void Interpret(Context context)  
      {  
           context.FormattedDate = date.Month + "-" +  
                date.Day + "-" + date.Year;  
      }  
 }  
   


   
   
 class GregorianDateExpression : AbstractDateExpression  
 {  
      public override void Interpret(Context context)  
      {  
           context.FormattedDate = date.Month + "-" +  
                date.Day + "-" + date.Year + " " +  
                date.Hour + ":" + date.Minute + ":" +  
                date.Millisecond;  
      }  
 }  

Kết quả và test thử

 AbstractDateExpression exp = new WordDateExpression();  
 exp.Interpret(context);  
   
 // ---Result   
 // Format for WordDateExpression: 202th day, Friday, July  
   
 exp = new CalendarDateExpression();  
 exp.Interpret(context);  
   
 // ---Result  
 // Formate for ClaendarDateExpression : 7-21-2006  
   
   
 exp = new GregorianDateExpression();  
 exp.Interpret(context);  
   
 // ---Result  
 // Format for GregorianDateExpression: 7-21-2006 15:47:95  

Vậy là thông qua Interpreters chúng ta đã có thể đưa ra kết quả mong muốn ứng với từng context...
Sử dụng mẫu interpreters còn có thể giúp chúng ta tạo lập các đối tượng thông qua file XML chứa metadata. Ví dụ thường gặp trong game đó là việc load các máp động, giao diện game, thay đổi hình nền game, ... thông qua các file đặc tả nằm độc lập (vì nếu tích hợp mỗi lần cập nhật map mới sẽ đẩy xuống client 1 lượng dữ liệu khổng lồ).

Thứ Hai, 24 tháng 9, 2012

Command Pattern

Tiếp tục với các mẫu Behavioral Pattern, Ở phần trước ta đã đi sơ qua về mẫu Chain of Responsibility và lần này chúng ta đến với một mẫu cũng tương tự... đó là Command Pattern


Command Pattern

Command Pattern là mẫu cho phép tất cả những Request đến object được lưu trữ trong chính object đó dưới dạng 1 object command. Có nghĩa là nếu bạn chuyển 1 Request (đóng gói dưới dạng 1 command object) tới 1 chức năng nào đó của object thì command object của Request đó sẽ được giữ lại bên trong object chính.

Khái niệm Command Object giống như một class trung gian được tạo ra chuyên để lưu trữ các câu lệnhtrạng thái của object tại một thời điểm nào đó. Hay có thể hiểu nôm na là đóng gói Request thành 1 class.

Tại sao ta cần đến việc lưu trữ những Object Command (hay lưu log các Request)???
Chắc hẳn bạn đã từng dùng NotePad hay bất cứ 1 text editor nào như winword ... Mỗi khi bạn muốn Undo hay Redo một hành động ... Và văn bản chuyển về các trạng thái phía trước hay sau đó ... Đó là ứng dụng của Command Object.

Command Object gồm có 3 phần chính là:
  • Invoker : Đây sẽ là nơi lưu trữ và phát sinh Request (dưới dạng Command Object).
  • Command : Là đối tượng lưu giữ RequestTrạng thái của đối tượng tại 1 thời điểm
  • Receiver : Là đối tượng thực hiện lệnh trên mỗi Request.
Sau đây là sơ đồ UML của mẫu Command  Pattern


Vấn đề: Đối tượng văn bản cần 1 cách nào đó để thêm hoặc lưu trữ những hành động undo hay redo
 
Document Object có thiết lập như sau
 //receiver  
 class Document  
 {  
   private ArrayList _textArray = new ArrayList();  
   public void Write(string text)  
   {  
      _textArray.Add(text);  
   }  
   public void Erase(string text)  
   {  
      _textArray.Remove(text);  
   }  
   public void Erase(int textLevel)  
   {  
      _textArray.RemoveAt(textLevel);  
   }  
   public string ReadDocument()  
   {  
      System.Text.StringBuilder sb = new System.Text.StringBuilder();  
      foreach(string text in _textArray)  
        sb.Append(text);  
      return sb.ToString();  
   }  
 }  

Giải pháp: Sử dụng 1 đối tượng Command như 1 Request để lưu trữ các Text và cho phép command xử lý yêu cầu Undo và Redo.

Ta xây dựng 1 chương trình dựa trên UML sau :


  • Trong đó đối tượng DocumentInstance sẽ là đối tượng người dùng thao tác trực tiếp và cũng là Invoker.
  •  Trong đối tượng DocumentInstance sẽ có 1 Array các CommandObject (với thể hiện là DocumentEditCommand) để lưu trữ trạng thái của văn bản.
  • Đối tượng DocumentEditCommand là thể hiện trực tiếp của lớp Command được sử dụng nó đóng vai trò là lớp ConcreteCommand trên mô hình UML chuẩn (hình đầu tiên)
  • Trong Document EditCommand sẽ có các Receiver là Document để thể hiện sự thay đổi trong từng giai đoạn Request.

Cài đặt:

 //base command  
 abstract class Command  
 {  
   abstract public void Redo();  
   abstract public void Redo();  
 }  

 //concrete implementation  
 class DocumentEditCommand : Command  
 {  
      private Document _editableDoc;  
      private string _text;  
      public DocumentEditCommand(Document doc, string text)  
      {  
           _editableDoc = doc;  
           _text = text;  
           _editableDoc.Write(_text);  
      }  
      override public void Redo()  
      {  
           _editableDoc.Write(_text);  
      }  
      override public void Undo()  
      {  
           _editableDoc.Erase(_text);  
      }  
 }  


 //invoker  
 class DocumentInvoker  
 {  
      private ArrayList _commands = new ArrayList();  
      private Document _doc = new Document();  
      public void Redo(int level)  
      {  
           Console.WriteLine("---- Redo {0} level", level);  
           ((Command) _commands[level]).Redo();  
      }  
      public void Undo(int level)  
      {  
           Console.WriteLine("---- Undo {0} level", level);  
           ((Command) _commands[level]).Undo();  
      }  
      public void Write(string text)  
      {  
           DocumentEditCommand cmd = new DocumentEditCommand(_doc, text);  
           _command.Add(cmd);  
      }  
      public string Read()  
      {  
           return _doc.ReadDocument();  
      }  
 }  

Việc cài đặt xong ... ta tiến hành chạy và kiểm tra kế quả có đúng với mong muốn hay không


 DocumentInvoker instance = new DocumentInvoker();  
 instance.Write("This is the original text.");  
   
 //---------Result--------------  
 // This is the original text. --first write  
   
 instance.Write(" Here is some other text.");  
   
 //---------Result---------------  
 // This is the original text. Here is some other text. --second write  
   
 instance.Undo(1);  
   
 //----------Result---------------  
 // ---- Undo 1 level  
 // This is the original text.  
   
 instance.Redo(1);  
   
 //----------Result----------------  
 // ---- Redo 1 level  
 // This is the original text. Here is some other text.  
   
 instance.Write(" And a little more text.");  
 instance.Undo(2);  
 instance.Redo(2);  
 instance.Undo(1);  
   
 //----------Result-----------------  
 // This is the original text. Here is some other text. And a little more text  
 // ----Undo 2 level  
 // This is the original text. Here is some other text.  
 // ----Redo 2 level  
 // This is the original text. Here is some other text. And a little more text.  
 // ---- Undo 1 level  
 // This is the original text. And a little more text.  
   


Kết luận : Mẫu Command giúp chúng ta giải quyết vấn đề xử lý các sự kiện 1 cách tuần tự lần lượt và có thể lưu log... Nó khá giống với mẫu Chain of Responsibility ở chỗ đều thực hiện các công việc một cách tuần tự nhưng cải tiến hơn ở cách quản lý tập trung theo 1 list và có thể quay lại về được bất kì bước nào ở phía trước.










Chain of Responsibility Pattern

dạo này thích viết bằng html hơn là dùng RichText nên mọi người thông cảm >:)

Nếu các bạn đã từng nghe qua về 23 mẫu Design Pattern của nhóm GOF thì thật tốt vì hôm nay chúng ta sẽ nói về mẫu lập trình trong 23 mẫu đó trong 1 bộ môn có tên là "Kiến trúc phần mềm" do Tiến Sỹ Trần Minh Triết đang giảng dạy...

23 mẫu Design Pattern thường dùng được chia thành 3 "phân vùng" gồm
  • Creational Patterns: các mẫu thiết kế thiên về tạo lập và quản lý tạo lập đối tượng
  • Behavioral Patterns: các mẫu thiết kế thiên về phương thức xử lý và quan hệ giữa các class
  • Structural Patterns: các mẫu thiết kế liên quan đến kiến trúc của phần mềm

Ngày hôm nay tạm gác qua các mẫu về Creational Patterns (sẽ được trình bày ở dịp khác) chúng ta đi vào phần Behavioral Patterns.

Như đã trình bày ở trên, các mẫu thiết kế liên quan đến behavioral patterns là những bài giải mẫu liên quan đến việc điều khiển các luồng xử lý và mối liên hệ giữa các class ... Bắt đầu luôn chứ không dài dòng nữa.


Mẫu số 1: Chain of Responsibility Pattern

Chain of Responbility để làm gì???
Giống như tên gọi của nó ... Chain of Responsibility là một mẫu thiết kế giải quyết cho việc thực hiện 1 chuỗi các tác vụ có trình tự mà mỗi 1 tác vụ trong chuỗi đó được đảm nhiệm bởi 1 class.

Ví dụ :
Mua bột --> Nhào bột --> Nướng bánh --> Nhậu

Đó là ví dụ đơn giản về 1 chuỗi các công việc. Mỗi công việc ở trên do một người đảm nhiệm:

phụ việc : đi chợ
phụ bếp : nhào bột
Đầu bếp : Nướng bánh
Thực khách : nhậu

Trong đó Phụ việc, phụ bếp, đầu bếp, thực khách là các class và Đi chợ(), nhào bột(), Nướng bánh(), nhậu() là các phương thức (method).

Hãy tưởng tượng đến 1 sợi dây xích có nhiều mắc xích ...

Trong mẫu Chain of Responsibility chúng ta có một thành phần chính là Handler. Handler là đối tượng đóng gói phương thức xử lý của instances này vào 1 instances khác (xem phần sau sẽ rõ)



Tạm quên UML của nó 1 bên vì nó không cung cấp nhiều thông tin lắm về mẫu này ... ta đến với vấn đề mẫu...

Vấn đề: Một nhóm các class xử lý theo lượt nhưng không có cách nào xác định thứ tự cái nào sẽ được gọi trước.

Ví dụ 1 luồng công việc như sau

 Process firstProcess = new FirstProcess();  
 fistProcess.Run();  
 Process secondProcess = new SecondProcess();  
 secondProcess.Run();  
 Process thirdProcess = new ThirdProcess();  
 thirdProcess.Run();  

Trong đó Process là lớp cha ... các lớp FirstProcess, SecondProcess, ThirdProcess() là các lớp kế thừa.

Giải quyết: Sử dụng một chuỗi class liên hợp để xử lý và định nghĩa bước thực hiện tiếp theo trong hàm xử lý của các class này.

Sơ đồ UML


Chúng ta đặt class thực thi tiếp theo vào class hiện tại, cho phép mỗi class chứa thể hiện (instance) của class tiếp theo trong chuỗi mắc xích.

#RunNext() bao gồm Run() và SetNextProcess()... 2 hàm này sẽ đảm bảo tại mỗi một mắc xích nó sẽ làm đúng nhiệm vụ của mình và ủy thác phần còn lại cho "mắc xích" tiếp theo cho đến khi hết.

Code cài đặt :


 abstract class Process  
 {  
   private Process _nextProcess;  
   protected abstract void RunNext();  
   public void Run()  
   {  
      RunNext();  
      if(_nextProcess != null)  
      {  
        _nextProcess.Run();  
      }  
   }  
   public void SetNextProcess(Process process)  
   {  
      _nextProcess = process;  
   }  
 }  


 class FirstProcess : Process  
 {  
   Protect override void RunNext()  
   {  
     System.Threading.Thread.Sleep(1000);  
   }  
 }  
 class SecondProcess: Process  
 {  
   Protect override void RunNext()  
   {  
     System.Threading.Thread.Sleep(2000);  
   }  
 }  
 class ThirdProcess: Process  
 {  
   Protect override void RunNext()  
   {  
     System.Threading.Thread.Sleep(3000);  
   }  
 }  

Thực thi vấn đề

 Process firstProcess = new FirstProcess();  
 Process secondProcess = new SecondProcess();  
 Process thirdProcess = new ThirdProcess();  
 firstProcess.SetNextProcess(secondProcess);  
 secondProcess.SetNextProcess(thirdProcess);  
 thirdProcess.SetNextProcess(null);  
 firstProcess.Run();  

Kết quả:

 Beginning first process ....  
 Ending first process ....  
 Beginning second process ....  
 Ending second process ....  
 Beginning third process ....  
 Ending third process ....  

Vậy ta đã thực thi được 1 chuỗi các hành động theo mắc xích bằng cách "chỉ ra mắc xích" tiếp theo của mắc xích hiện tại... Đó cũng là tinh thần của Chain of Responbility...