Esercitazione del modello Builder in .NET

Definizione del modello Builder:

Separare la costruzione di un oggetto complesso dalla sua rappresentazione, in modo che lo stesso processo di costruzione possa creare diverse rappresentazioni, questo modello di design è chiamato modello Builder

Diagramma della struttura del modello Builder:

Ruoli del modello Builder:

1 builder: Specifica un'interfaccia astratta per i componenti di un oggetto di prodotto.
2 ConcreteBuilder: Implementa l'interfaccia Builder per costruire e assemblare le varie parti del prodotto, definisce chiaramente la rappresentazione che crea e fornisce un'interfaccia di ricerca del prodotto.
3 Director：构造一个使用Builder接口的对象。
4 Product：表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包括将这些部件装配成最终产品的接口。

下面通过过现实生活中的建房子的例子，来诠释建造者模式：

1. 抽象出建造者接口，里面有待实现的创建房子种类的条件，创建后返回房间的数量，以及这件房子的描述信息。

 /// <summary>
 /// 抽象建造者
 /// </summary>
 public interface IHouse
 {
 /// <summary>
 /// 创建房子种类的条件
 /// </summary>
 /// <returns></returns>
 bool GetBackyard();
 /// <summary>
 /// 创建的房间数
 /// </summary>
 /// <returns></returns>
 long NoOfRooms();
 /// <summary>
 /// 描述
 /// </summary>
 /// <returns></returns>
 string Description();
 }

2. 继承IHouse接口，具体建造者，这里创建了一件房间，里面包括客厅，厨房，洗手间，卧室，共四件房间这样一座房子。

 public class CRoom
 {
 public string RoomName { get; set; }
 }
 /// <summary>
 /// 具体建造者
 /// </summary>
 public class CSFH:IHouse
 {
 private bool mblnBackyard;
 private Hashtable Rooms;
 public CSFH() {
 CRoom room = new CRoom();
 room.RoomName = "一楼客厅";
 Rooms = new Hashtable();
 Rooms.Add("room1", room);
 room = new CRoom();
 room.RoomName = "一楼厨房";
 Rooms.Add("room2", room);
 room = new CRoom();
 room.RoomName = "一楼洗手间";
 Rooms.Add("room3", room);
 room = new CRoom();
 room.RoomName = "一楼卧室";
 Rooms.Add("room4",room);
 mblnBackyard = true;
 }
 public bool GetBackyard()
 {
 return mblnBackyard;
 }
 public long NoOfRooms()
 {
 return Rooms.Count;
 }
 public string Description()
 {
 IDictionaryEnumerator myEnumerator = Rooms.GetEnumerator();
 string strDescription = "这个房子共 " + Rooms.Count + " 间 \n";
 while (myEnumerator.MoveNext())
 {
 strDescription = strDescription + "\n" + myEnumerator.Key + "\t" + ((CRoom)myEnumerator.Value).RoomName; 
 }
 return strDescription;
 }
 }

3. 继承IHouse接口，具体建造者，这里创建了一件房子，里面只包括卧室，客厅，厨房共三件房间这样一座房子。

 /// <summary>
 /// 其他具体建造者
 /// </summary>
 public class CApt:IHouse
 {
 private bool mblnBackyard;
 private Hashtable Rooms;
 public CApt()
 { 
 Rooms = new Hashtable();
 CRoom room = new CRoom();
 room.RoomName = "Camera da letto";
 Rooms.Add("room1", room);
 room = new CRoom();
 room.RoomName = "Soggiorno";
 Rooms.Add("room2", room);
 room = new CRoom();
 room.RoomName = "Cucina";
 Rooms.Add("room3", room);
 mblnBackyard = false;
 }
 public bool GetBackyard()
 {
 return mblnBackyard;
 }
 public long NoOfRooms(){
 return Rooms.Count; 
 }
 public string Description(){
 IDictionaryEnumerator myEnumerator = Rooms.GetEnumerator();
 string strDescription = "Questa casa ha in totale " + Rooms.Count + " stanze \n";
 while (myEnumerator.MoveNext())
 {
  strDescription = strDescription + "\n" + myEnumerator.Key + "\t" + ((CRoom)myEnumerator.Value).RoomName; 
 }
 return strDescription;
 }
 }

4. Creazione del direttore, istruzioni per determinare quale costruttore costruisca quale tipo di stanza.

 /// <summary>
 /// Direttore
 /// </summary>
 public class CDirector
 {
 public IHouse BuildHouse(bool blnBackyard)
 {
 if (blnBackyard)
 {
 return new CSFH();
 }
 else
 {
 return new CApt(); 
 }
 }
 }

5. Creazione:

 static void Main(string[] args)
 {
 CDirector objDirector = new CDirector(); // Istanzia il direttore
 IHouse objHouse;
 string Input = Console.ReadLine(); // Inserisci le istruzioni per determinare quale creatore crea la stanza
 objHouse = objDirector.BuildHouse(bool.Parse(Input));
 Console.WriteLine(objHouse.Description());
 Console.ReadLine();
 }

Il modello Builder è principalmente utilizzato per “costruire un oggetto complesso in fasi”, in cui “fasi” è un algoritmo stabile, mentre le parti dell'oggetto complesso cambiano spesso

Il prodotto non necessita di una classe astratta, specialmente nei casi in cui l'algoritmo di creazione dell'oggetto è complesso e si utilizza questo modello, o quando questo modello viene applicato al processo di generazione del prodotto, i risultati finali possono differire notevolmente e non è probabile che si possa estrarre una classe prodotto astratta.

Il modello di fabbrica astratta risolve le variazioni di esigenze di “serie di oggetti”, mentre il modello Builder risolve le variazioni di esigenze di “parti di oggetto”.

L'uso del modello Builder rende possibile che l'aspetto interno del prodotto possa cambiare indipendentemente. L'uso del modello Builder può far sì che il client non debba conoscere i dettagli della composizione interna del prodotto

Ogni Builder è relativamente indipendente e non ha nulla a che fare con altri Builder.

Il modello Builder è adatto per i casi in cui le proprietà dell'oggetto da generare sono interdipendenti, il modello Builder può forzare l'ordine di generazione. Gli oggetti da generare hanno una struttura interna complessa.

Questo è tutto il contenuto dell'articolo, speriamo che sia utile per la tua apprendimento e che tu sostenga fortemente il tutorial di urla.

Dichiarazione: il contenuto di questo articolo è stato prelevato da Internet, i diritti d'autore appartengono agli autori originali, il contenuto è stato contribuito autonomamente dagli utenti di Internet e caricato autonomamente, il sito web non detiene i diritti di proprietà, non è stato elaborato manualmente e non assume alcuna responsabilità legale correlata. Se trovi contenuti sospetti di violazione del copyright, ti preghiamo di inviare una e-mail a notice#oldtoolbag.com (sostituisci # con @) per segnalare il problema e fornire prove pertinenti. Una volta verificata la veridicità, il sito web rimuoverà immediatamente il contenuto sospetto di violazione del copyright.