.NET-Builder-Muster erklärt

Definition des Builder-Musters:

Trennung der Konstruktion eines komplexen Objekts von seiner Darstellung, sodass mit demselben Konstruktionsprozess unterschiedliche Darstellungen erstellt werden können. Dieses Entwurfsmuster wird als Builder-Muster bezeichnet.

Builder Musterstrukturdiagramm:

Builder-Musterrolle:

1 Builder: zum Erstellen eines Produktobjekts. Jede Komponente spezifiziert eine abstrakte Schnittstelle.
2 ConcreteBuilder: Implementieren Sie die Builder-Schnittstelle, um die verschiedenen Komponenten des Produkts zu konstruieren und zusammenzubauen, die von ihm erstellte Darstellung zu definieren und zu klären und eine Schnittstelle zum Abrufen des Produkts bereitzustellen.
3 Director: Konstruieren Sie ein Objekt mithilfe der Builder-Schnittstelle.
4 Produkt: Stellt ein konstruiertes komplexes Objekt dar. ConcreteBuilder erstellt eine interne Darstellung des Produkts und definiert seinen Montageprozess, einschließlich der Klassen, die die Komponententeile definieren, einschließlich der Schnittstellen für den Zusammenbau dieser Teile zum Endprodukt.

Das Folgende ist ein Beispiel für den Bau eines Hauses im wirklichen Leben, um das Builder-Muster zu erklären:

1. Zusammenfassung der Builder-Schnittstelle, die die Bedingungen für die Erstellung eines zu implementierenden Haustyps enthält. Nach der Erstellung werden die Anzahl der Zimmer und die Beschreibung des Hauses zurückgegeben.

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

2. Erben Sie die IHouse-Schnittstelle, den spezifischen Builder, der hier einen Raum erstellt, der ein Wohnzimmer, eine Küche, ein Badezimmer usw. umfasst ein Schlafzimmer, insgesamt vier. In einem solchen Haus gibt es nur wenige Räume.

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. Übernehmen Sie die IHouse-Schnittstelle, den spezifischen Builder, der hier ein Haus erstellt, das nur drei Räume umfasst: Schlafzimmer, Wohnzimmer und Küche . So ein Haus.

/// <summary>
/// 其他具体建造者
/// </summary>
public class CApt:IHouse
{
private bool mblnBackyard;
private Hashtable Rooms;
 
public CApt()
{
Rooms = new Hashtable();
CRoom room = new CRoom();
room.RoomName = "卧室";
Rooms.Add("room1", room);
 
room = new CRoom();
room.RoomName = "客厅";
Rooms.Add("room2", room);
 
room = new CRoom();
room.RoomName = "厨房";
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 = "这个房子一共 " + Rooms.Count + " 间 \n";
while (myEnumerator.MoveNext())
{
 strDescription = strDescription + "\n" + myEnumerator.Key + "\t" + ((CRoom)myEnumerator.Value).RoomName;
}
return strDescription;
}
}

4. Erstellen Sie einen Leitfaden, der angibt, welcher Bauunternehmer welche Art von Raum bauen soll.

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

5. Erstellen Sie:

static void Main(string[] args)
{
CDirector objDirector = new CDirector();//实例化指导者
IHouse objHouse;
string Input = Console.ReadLine();//输入条件指导哪位创建者创建房间
objHouse = objDirector.BuildHouse(bool.Parse(Input));
Console.WriteLine(objHouse.Description());
Console.ReadLine();
}

Builder Mode Main Used „ein komplexes Objekt in Schritten aufbauen“, wobei „Schritt für Schritt“ ein stabiler Algorithmus ist, während sich die Teile des komplexen Objekts häufig ändern

Abstrakte Klassen sind für das Produkt nicht erforderlich, insbesondere aufgrund der Erstellung Wenn dieses Muster aufgrund der Komplexität des Objektalgorithmus verwendet wird oder wenn dieses Muster auf den Produktgenerierungsprozess angewendet wird, können die Endergebnisse stark variieren und es ist unwahrscheinlich, dass eine abstrakte Produktklasse verfeinert wird.

Das vorherige abstrakte Fabrikmuster löst die Bedarfsänderungen von „Serienobjekten“ und das Builder-Muster löst die Bedarfsänderungen von „Objektteilen“.

Durch die Verwendung des Builder-Musters kann das innere Erscheinungsbild des Produkts unabhängig geändert werden. Die Verwendung des Builder-Musters ermöglicht es dem Kunden, die Details der internen Zusammensetzung des Produkts nicht zu kennen

Jeder Builder ist relativ unabhängig und hat nichts mit anderen Buildern zu tun.

Das Builder-Muster eignet sich für Eigenschaften von Produktobjekten, die generiert werden müssen. Das Builder-Muster kann die Generierungsreihenfolge erzwingen. Die zu generierenden Produktobjekte weisen komplexe interne Strukturen auf.