Tech News

“Match interfaces of different classes”

Rules of thumb

• Adapter makes things work after they’re designed; Bridge makes them work before they are.
• Bridge is designed up-front to let the abstraction and the implementation vary independently. Adapter is retrofitted to make unrelated classes work together.
• Adapter provides a different interface to its subject. Proxy provides the same interface. Decorator provides an enhanced interface.
• Adapter is meant to change the interface of an existing object. Decorator enhances another object without changing its interface. Decorator is thus more transparent to the application than an adapter is. As a consequence, Decorator supports recursive composition, which isn’t possible with pure Adapters.
• Facade defines a new interface, whereas Adapter reuses an old interface. Remember that Adapter makes two existing interfaces work together as opposed to defining an entirely new one.

Kịch bản của mẫu Adapter

Nhưng khi hệ thống thay đổi, nó yêu cầu một đối tượng Acme ( không phải Ace), vì vậy đối tượng Ace không thích hợp nữa. Xem hình sau:

 “Tôi có một giải pháp”. Bạn nói. Mọi người quay sang, và bạn nói tiếp ”Dĩ nhiên, với tư cách là một tư vấn viên, tôi sẽ tính chi phí cao cho việc này”

“OK”, trưởng nhóm nói.

“Bạn cần sử dụng mẫu chuyển đổi Adapter”, bạn giải thích, “Mẫu adapter cho phép bạn chuyển đổi một lớp hoặc một đối tượng sang một lớp hoặc đối tượng mới mà bạn mong muốn”. Bạn vẽ ra giải pháp lên tấm bảng như hình sau:

Xem source code đính kèm

Ref
https://sourcemaking.com/design_patterns/adapter
https://haihth.wordpress.com/2013/02/23/dp-chapter6/

“Defer the exact steps of an algorithm to a subclass”

Rules of thumb

• Strategy is like Template Method except in its granularity.
• Template Method uses inheritance to vary part of an algorithm. Strategyuses delegation to vary the entire algorithm.
• Strategy modifies the logic of individual objects. Template Methodmodifies the logic of an entire class.
• Factory Method is a specialization of Template Method.

Download full source code here

“Tin tốt”, giám đốc GigundoCorp – một công ty mới mà bạn đang nhận trách nhiệm tư vấn –  vừa nói trong khi chạy vào phòng họp “Chúng ta đã nhận được hợp đồng đó”

“Hợp đồng nào?”, mọi người hỏi

“Hợp đồng về những con rô bốt tự động lắp ráp xe hơi”, vị giám đốc nói.

Tạo robo đầu tiên

public class cRobo{

    public cRobo()
    {

    }

    public void go() 
    {
        start();
        getParts();
        assemble();
        test();
        stop();
    }

    public void start()
    {
        Console.WriteLine("staring ...");
    }

    public void getParts()
    {
        Console.WriteLine("Getting a carburetor ...");
    }

    public void assemble()
    {
        Console.WriteLine("assembling ...");
    }

    public void test()
    {
        Console.WriteLine("Testing ...");
    }

    public void stop()
    {
        Console.WriteLine("Stopping ...");
    }

} 

public static void main() {
    cRobo robo = new cRobo(); 
    robo.go();
}

khi chạy chương trình …

Staring ….
Getting a carburetor …
assembling …
Testing …
Stopping …

“Tuyệt vời”, giám đốc điều hành phấn khích. “Phần thưởng luôn ở xung quanh. Tôi đã nói với anh rằng họ không cần cái thứ mẫu thiết kế vớ vấn”. Các lập trình viên của công ty ném cho bạn một ánh nhìn dè bỉu.

Tạo Robot với Mẫu thiết kế Template Method

 
Nhưng bây giờ họ cần một con robot nướng bánh như hình sau, và thế là phải viết lại mã nguồn từ đầu

 public void go() 
 {
        start();
        getParts();
        assemble();
        test();
        stop();
 }

Tạo robot bằng bộ khuôn Template

Nếu bạn có một bộ khuôn Template dựa trên robot, bạn có thể cho nó kế thừa như hình sau:

Bằng cách gọi hàm go, tập hợp các thuật toán sẽ được thực hiện. Để tùy chỉnh trong lớp kế thừa, bạn chỉ cần viết lại một số bước nào bạn muốn, trong trường hợp robot nướng bánh sẽ như hình sau:

Ref
https://haihth.wordpress.com/2013/02/23/dp-chapter7/
https://sourcemaking.com/design_patterns/template_method

“Separates object construction from its representation”

Rules of thumb

• Sometimes creational patterns are complementory: Builder can use one of the other patterns to implement which components get built. Abstract Factory, Builder, and Prototype can use Singleton in their implementations.
• Builder focuses on constructing a complex object step by step. Abstract Factory emphasizes a family of product objects (either simple or complex). Builder returns the product as a final step, but as far as the Abstract Factory is concerned, the product gets returned immediately.
• Builder often builds a Composite.
• Often, designs start out using Factory Method (less complicated, more customizable, subclasses proliferate) and evolve toward Abstract Factory, Prototype, or Builder (more flexible, more complex) as the designer discovers where more flexibility is needed.

Download full source code here

Xây dựng Robots với mẫu Builder

“Tin tốt!” Giám đốc điều hành của GigundoCorp reo  lên, trong khi phóng như bay vào phòng họp.

Những quy định của khách hàng

Mọi chức năng đều dựa trên khuôn mẫu Template trong mẫu thiết kế này, và bạn có thể tùy chỉnh template theo cách bạn muốn. Nhưng bây giờ bạn không còn điều khiển thuật toán nữa, thay vào đó chính khách hàng thực hiện. Họ tạo robot với những chức năng và trình tự họ muốn. Ví dụ để thêm hành động khởi động, khách hàng có thể gọi hàm addStart. Để thêm hành động kiểm tra, họ gọi hàm addTest và ….

Nhờ đó, khách hàng có thể sử dụng CookieRobotBuilder để tạo robot nướng bánh. Khi khách hàng tạo xong robot, mã nguồn sẽ gọi hàm getRobot của đối tượng CookieRobotBuilder để nhận về một robot mới,

Ref
https://sourcemaking.com/design_patterns/builder
https://haihth.wordpress.com/2013/02/23/dp-chapter7/

“Add responsibilities to objects dynamicall”

Rules of thumb

– Adapter provides a different interface to its subject. Proxy provides the same interface. Decorator provides an enhanced interface.
– Adapter changes an object’s interface, Decorator enhances an object’s responsibilities. Decorator is thus more transparent to the client. As a consequence, Decorator supports recursive composition, which isn’t possible with pure Adapters.
– A Decorator can be viewed as a degenerate Composite with only one component. However, a Decorator adds additional responsibilities – it isn’t intended for object aggregation.
– Decorator is designed to let you add responsibilities to objects without subclassing. Composite’s focus is not on embellishment but on representation. These intents are distinct but complementary. Consequently, Composite and Decorator are often used in concert.
– Decorator and Proxy have different purposes but similar structures. Both describe how to provide a level of indirection to another object, and the implementations keep a reference to the object to which they forward requests.
– Decorator lets you change the skin of an object. Strategy lets you change the guts.

Download full source code use abstract class – CSharp

Download full source code use interface – CSharp

Giữ vững nguyên tắc viết mã “Open-Close” hay “Luôn mở cho việc mở rộng, nhưng đóng cho việc sửa đổi”

public class cComputer  
{
        public cComputer() { }
        public string description()
        {
            return "You're getting a computer";
        }
}

public class cComputer  
{
        public cComputer() { }
        public string description()
        {
            return "You're getting a computer and a disk";
        }
}

Bây giờ khi một đối tượng computer được tạo và bạn gọi phương thức description, bạn sẽ nhận được văn bản “You’re getting a computer and a disk.” Nhưng một vài khách hàng vẫn chưa hài lòng. Họ muốn thêm một cái màn hình nữa. Và thế là các lập trình viên phải chỉnh sửa tiếp như sau:

public class cComputer  
{
        public cComputer() { }
        public string description()
        {
            return "You're getting a computer and a disk and a monitor";
        }
}

Bây giờ, khi bạn tạo một computer và gọi phương thức description bạn sẽ thấy

"You're getting a computer and a disk and a monitor";

VÍ DỤ VỀ MẪU TRANG TRÍ DECORATOR

Example:

Bạn bắt đầu viết một lớp máy tính Computer đơn giản, với một phương thức description trả về kết quả “computer” như sau:

public class cComputer
{
        public cComputer() { }

        public string description()
        {
            return "computer";
        }

} 

Tạo dựng một Lớp trang trí Decorator

public interface IComputer
{
        string description();
}

Thêm vào một đĩa cứng Disk

Đây là lớp bao bọc Disk , sẽ thêm một ổ cứng vào máy tính. Bởi vì đây là một lớp bao bọc, nó cần phải biết đang bao bọc thứ gì. Vì vậy bạn đưa cho nó một đối tượng computer ngay khi nó khởi tạo. Lớp bao bọc Disk sẽ lưu trữ một đối tượng tên computer

Bây giờ bạn cần hiện thực phương thức Description. Phương thức mới này sẽ gọi phương thức description của lớp computer và thêm vào dòng chữ “and a disk” như sau:

public class cDisk : IComputer
{
        IComputer _icomp;
        public cDisk(IComputer c) 
        {
            _icomp = c;
        }

        public string description()
        {
            return _icomp.description() + " and a disk";

        }
} 

Vậy là bạn đã bao bọc đối tượng computer, và khi bạn gọi phương thức description của đối tượng disk này, nó sẽ gọi phương thức description của lớp computer, đồng thời thêm vào dòng chữ “and a disk”. Kết quả bạn sẽ có “computer and a disk”

Thêm vào một màn hình monitor

Tương tự với monitor

public class cMonitor : IComputer
{
        IComputer _icomp;

        public cMonitor(IComputer c)
        {
            _icomp = c;
        }

        public string description()
        {
            return _icomp.description() + " and a Monitor";
        }
}

OK. Bạn đã có đầy đủ các lớp. Giờ là lúc chạy thử nghiệm chương trình.
Đầu tiên bạn tạo đối tượng computer như sau:

static void Main(string[] args)
{
            IComputer comp = new cComputer();   // implements interface IComputer            
            Console.ReadLine();
} 

Sau đó bạn bao bọc đối tượng computer để thêm vào một Monitor

static void Main(string[] args)
{
            IComputer comp = new cComputer();   // implements interface IComputer
            
            // add 1 Monitor
            comp = new cMonitor(comp); 
            Console.ReadLine();
}

Bây giờ hãy thêm vào 2 Disk, Cuối cùng bạn gọi phương thức description của lớp bao bọc để xem kết quả:

static void Main(string[] args)
{
            IComputer comp = new cComputer();   // implements interface IComputer
           
            // add 1 Monitor
            comp = new cMonitor(comp);  

            // and 2 Disk
            comp = new cDisk(comp);     
            comp = new cDisk(comp);  
            Console.WriteLine(string.Format("you're getting: {0}" , comp.description()));
            Console.ReadLine();
}

OK. Khi chạy chương trình bạn nhận được kết quả.

you’re getting: a computer and a monitor and a disk and a disk

Không tồi. Bạn đã mở rộng một đối tượng gốc thật đơn giản bằng cách bao bọc nó trong nhiều lớp trang trí decorator khác nhau, tránh việc phải chỉnh sửa trong mã nguồn gốc. Và đó là Mẫu Thiết Kế Trang Trí Decorator.

Download full source code use abstract class – CSharp

Download full source code use interface – CSharp

Ref: 
https://haihth.wordpress.com/2013/02/21/dp-chapter3/
https://sourcemaking.com/design_patterns/decorator

 “Creates an instance of several families of classes”

Rules of thumb

• Abstract Factory classes are often implemented with Factory Methods, but they can be implemented using Prototype.
• Factory Methods are usually called within Template Methods.
• Factory Method: creation through inheritance. Prototype: creation through delegation.
• Often, designs start out using Factory Method (less complicated, more customizable, subclasses proliferate) and evolve toward AbstractFactory, Prototype, or Builder (more flexible, more complex) as the designer discovers where more flexibility is needed.
• Prototype doesn’t require subclassing, but it does require an Initialize operation. Factory Method requires subclassing, but doesn’t require Initialize.
• The advantage of a Factory Method is that it can return the same instance multiple times, or can return a subclass rather than an object of that exact type.
• Some Factory Method advocates recommend that as a matter of language design (or failing that, as a matter of style) absolutely all constructors should be private or protected. It’s no one else’s business whether a class manufactures a new object or recycles an old one.
• The new operator considered harmful. There is a difference between requesting an object and creating one. The newoperator always creates an object, and fails to encapsulate object creation. A Factory Method enforces that encapsulation, and allows an object to be requested without inextricable coupling to the act of creation.

Download full source code here

Tại đây, công ty MegaGigaCo, bạn được trả lương cao cho kỹ năng thiết kế mẫu chuyên nghiệp của mình, bạn đang tạo một đối tượng kết nối cơ sở dữ liệu mới

cConnection conn = new cOracleConnection();

cConnection conn = new cSqlServerConnecton();

“Tốt lắm” Vị giám đốc nói. “Umh, vậy làm sao để kết nối với MySQL? Chúng ta muốn nó là kết nối mặc định”. “Woa”, bạn hơi bối rối. Tuy nhiên bạn vẫn làm thêm một kết nối với MySQL như sau:

cConnection conn = new cMySqlServerConnecton();

Hiện tại bạn đã có ba loại kết nối cơ sở dữ liệu như sau: Oracle, SQL Server và MySQL. Vì vậy bạn chỉnh sửa mã nguồn cho phù hợp với các biến như “Oracle”, “SQL Server” hay bất cứ biến nào khác như sau:

if (type.equals("Oracle"))
    conn = new cOracleConnection();
    

else if (type.equals("SQL Server"))
    conn = new cSqlServeverConnection();    

else
    conn = new cMySqlServerConnection(); 

1st Exam:

abstract class Address
{
    public abstract void Show();
}

abstract class Phone
{
 public abstract void Show();
}

abstract class Factory
{
 virtual public Address createAddress()
 {
  return null;
 }
 virtual public Phone createPhone()
 {
  return null;
 }
}

class USAddress: Address
{
 public override void Show()
 {
  Console.WriteLine("USA Address");
 }
}

class USPhone: Phone
{
 public override void Show()
 {
  Console.WriteLine("USA Phone");
 }
}

class VNAddress: Address
{
 public override void Show()
 {
  Console.WriteLine("Viet Nam address");
 }
}

class VNPhone:Phone
{
 public override void Show()
 {
  Console.WriteLine("Viet Nam phone");
 }
}

class USFactory: Factory
{
 public override Address createAddress()
 {
  return new USAddress();
 }
 public override Phone createPhone()
 {
  return new USPhone();
 }
}

class VNFactory:Factory
{
 public override Address createAddress()
 {
  return new VNAddress();
 }
 public override Phone createPhone()
 {
  return new VNPhone();
 }
}

class Program
{
 static void Main(string[] args)
 {
  Factory factory = new VNFactory();
  Address address = factory.createAddress();
  Phone phone = factory.createPhone();
    
  Console.WriteLine("Create Object by VNFactory");
  address.Show();
  phone.Show();

  factory = new USFactory();
  address = factory.createAddress();
  phone = factory.createPhone();

  Console.WriteLine("Create Object by USFactory");
  address.Show();
  phone.Show();

  Console.ReadKey();
 }
}

2nd Exam:

Ref:
https://sourcemaking.com/design_patterns/factory_method
https://haihth.wordpress.com/2013/02/21/dp-chapter3/