設計模式c#語言描述——建造者模式、適配器模式、合成（Composite）模式

設計模式c#語言描述——建造者模式

<script language="javascript" src="/ad/js/edu_left_300-300.js" type="text/javascript"> </script>

設計模式c#語言描述——建造者（builder）模式

*本文參考了《JAVA與模式》的部分內容，適合於設計模式的初學者。

建造模式是對象的創建模式。建造模式可以將一個產品的內部表象與產品的生成過程分割開來，從而可以使一個建造過程生成具有不同的內部表象的產品對象。
一個產品常有不同的組成成分作爲產品的零件，它們通常叫做產品的內部表象。不同的產品可以有不同的內部表象，也就是不同的零件。使用建造模式可以使客戶不需要知道所生成的產品的對象有哪些零件，每個產品的對應零件彼此有何不同，是怎麼建造出來的，以及怎樣組成產品。下面是一個示例性的實現。

在這個示例性的系統中，最終產品Product只有兩個零件，即Part1和Part2.相應的建造方法也有兩個：builderPart1和builderPart2.可以看出本模式涉及到四個角色：

抽象建造者（Builder）：給出一個抽象接口，以規範產品對象的各個組成部分的建造。

具體建造者（Concrete Builder）：擔任這個角色的是與應用程序緊密相關的一些類，它們在應用程序的調用下創建產品的實例。

導演者（Director）：是與客戶端打交道的角色，將創建產品的請求劃分爲對各個零件的建造請求，再將這些請求委派給具體建造者。

產品（Product）：建造中的對象。


Builder:

public interface Builder
{
void buildPart1();
void buildPart2();

Product retrieveResult();
}// END INTERFACE DEFINITION Builder

ConcreteBuilder:

public class ConcreteBuilder : Builder
{
private Product product;
public void buildPart1()
{
//build the first part of the product
}

public void buildPart2()
{
//build the second part of the product
}
public Product retrieveResult()
{
return product;
}

}// END CLASS DEFINITION ConcreteBuilder

Director:
public class Director
{
private Builder builder;

public void Director()
{ }

public void construct()//產品構造方法，負責調用各個零件建造方法
{
builder=new ConcreteBuilder();

builder.builderPart1();
builder.builderPart2();
builder.retrieveResult();
}

}// END CLASS DEFINITION Director

Product:

public interface Product
{
}// END INTERFACE DEFINITION Product

上面的系統中只有一個產品類，對應地也有一個具體建造者類。有多個產品及建造者類的建造模式如下圖：

設計模式c#語言描述——適配器模式

<script language="javascript" src="/ad/js/edu_left_300-300.js" type="text/javascript"> </script>

設計模式c#語言描述——適配器（Adapter）模式

*本文參考了《JAVA與模式》的部分內容，適合於設計模式的初學者。

適配器模式把一個類的接口變換成客戶端所期待的另一種接口，從而使原本因接口不匹配而無法在一起工作的兩個類能夠在一起工作。包括類的適配器模式和對象的適配器模式兩種不同的形式。

類的適配器模式把被適配的類的API轉換成爲目標類的API，其靜態結構圖如下：
模式的角色如下：

目標（Target）角色：這就是所期待得到的接口。注意這裏討論的是類的適配器模式，因此目標不可以是類。

源（Adaptee）角色：現有需要適配的接口。

適配器（Adapter）角色：把源接口轉換成目標接口。

Target;

public interface Target
{
void sampleOperation1();
void sampleOperation2();//源類不包含的方法
}                 // END INTERFACE DEFINITION Target



Adaptee;

public class Adaptee
{
public void sampleOperation1()
{ }
}// END CLASS DEFINITION Adaptee

Adapter;

public class Adapter : Adaptee,Target
{
public void sampleOperation2()
{ }
}// END CLASS DEFINITION Adapter

類的適配器模式的效果：

使用一個具體類把源適配到目標中，這樣一來，如果源以及源的子類都使用此類適配，就形不通了。

由於適配器類是源的子類，因此可以在適配器類中置換掉（Override）源的一些方法。

與類的適配器模式相似，對象的適配器模式把被適配的類的API轉換成目標類的API，與類的適配器模式不同，對象的適配器模式不是使用繼承關係連接到Adaptee類，而是使用委派關係，類圖如下所示：


Target;

public interface Target
{
void sampleOperation1();
void sampleOperation2();

}// END INTERFACE DEFINITION Target

Adaptee;
public class Adaptee
{
public void sampleOperation1()
{ }

}// END CLASS DEFINITION Adaptee

Adapter:

public class Adapter : Target
{
private Adaptee adaptee;

public void Adapter(Adaptee adaptee)
{
this.adaptee=adaptee;
}
public void sampleOperation1()
{
adaptee.sampleOperation1();
}

public void sampleOperation2()
{ }

}// END CLASS DEFINITION Adapter


對象適配器模式的效果：

一個適配器可以把多種不同的源適配到同一個目標。也就是說，同一個適配器可以把源類和它的子類都適配到目標接口。

與類的適配器相比，要想置換源類的方法就不容易。如果一定要置換源類的方法，就只好先做一個源類的子類，將方法置換掉，再把源類的子類當作真正的源進行適配。

設計模式c#語言描述——合成（Composite）模式

<script language="javascript" src="/ad/js/edu_left_300-300.js" type="text/javascript"> </script>

設計模式c#語言描述——合成（Composite）模式



*本文參考了《JAVA與模式》的部分內容，適合於設計模式的初學者。



合成模型模式屬於對象的結構模式，有時又叫做部分-整體模式。合成模式將對象組織到樹結構中，可以用來描述整體與部分的關係。合成模式可以使客戶端將單純元素與複合元素同等看待。如文件夾與文件就是合成模式的典型應用。根據模式所實現接口的區別，合成模式可分爲安全式和透明式兩種。



安全式的合成模式要求管理聚集的方法只出現在樹枝構件類中，而不出現在樹葉構件類中。類圖如下所示：


涉及到三個角色：



抽象構件（Component）：這是一個抽象角色，它給參加組合的對象定義公共的接口及其默認的行爲，可以用來管理所有的子對象。合成對象通常把它所包含的子對象當做類型爲Component的對象。在安全式的合成模式裏，構件角色並不定義出管理子對象的方法，這一定義由樹枝構件對象給出。

樹葉構件（Leaf）：樹葉對象是沒有下級子對象的對象，定義出參加組合的原始對象的行爲。

樹枝構件（Composite）：代表參加組合的有下級子對象的對象。樹枝構件類給出所有的管理子對象的方法，如Add（），Remove（）等。



Component:

public interface Component
{

 void sampleOperation();

}// END INTERFACE DEFINITION Component

Leaf:

public class Leaf : Component
{
public void sampleOperation() 
{ }

}// END CLASS DEFINITION Leaf

Composite:

public class Composite :Component
{
private ArrayList componentList=new ArrayList();
public void sampleOperation()
{
System.Collections.IEnumerator myEnumerator = componentList.GetEnumerator();
while ( myEnumerator.MoveNext() )
{
((Component)myEnumerator.Current).sampleOperation();
}
}
public void add(Component component)
{
componentList.Add (component);
}

public void remove(Component component)
{
componentList.Remove (component);
}
}// END CLASS DEFINITION Composite

與安全式的合成模式不同的是，透明式的合成模式要求所有的具體構件類，不論樹枝構件還是樹葉構件，均符合一個固定的接口。類圖如下所示：

抽象構件（Component）：這是一個抽象角色，它給參加組合的對象定義公共的接口及其默認的行爲，可以用來管理所有的子對象。要提供一個接口以規範取得和管理下層組件的接口，包括Add（），Remove（）。

樹葉構件（Leaf）：樹葉對象是沒有下級子對象的對象，定義出參加組合的原始對象的行爲。樹葉對象會給出Add（），Remove（）等方法的平庸實現。

樹枝構件（Composite）：代表參加組合的有下級子對象的對象。定義出這樣的對象的行爲。

Component:

public interface Component
{
void sampleOperation();
void add(Component component);
void remove(Component component);

}// END INTERFACE DEFINITION Component

Leaf:

public class Leaf : Component
{
private ArrayList componentList=null;
public void sampleOperation()
{ }

public void add(Component component)
{ }

public void remove(Component component)
{ }

}// END CLASS DEFINITION Leaf

Composite:

public class Composite :Component
{
private ArrayList componentList=new ArrayList();
public void sampleOperation()
{
System.Collections.IEnumerator myEnumerator = componentList.GetEnumerator();
while ( myEnumerator.MoveNext() )
{
((Component)myEnumerator.Current).sampleOperation();
}
}

public void add(Component component)
{
componentList.Add (component);
}

public void remove(Component component)
{
componentList.Remove (component);
}

}// END CLASS DEFINITION Composite