.NET builder pattern explained

Definition of builder pattern:

Separates the construction of a complex object from its representation, so that the same construction process can create different representations. Such a design pattern is called the builder pattern

Builder pattern structure diagram:

Builder pattern roles:

1 builder: Specify abstract interfaces for each component that creates a product object.
2 ConcreteBuilder: Implement the Builder interface to construct and assemble the various components of the product, define and clarify the representation it creates, and provide an interface for retrieving the product.
3 Director: Construct an object using the Builder interface.
4 Product: Represents a constructed complex object. ConcreteBuilder creates an internal representation of the product and defines its assembly process, including the classes that define the component parts, including the interfaces for assembling those parts into the final product.

The following is an example of building a house in real life to explain the builder pattern:

1. Abstract the builder interface, which contains the conditions for creating a house type to be implemented, the number of rooms returned after creation, and this item Description of the house.

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

2. Inherit the IHouse interface, the specific builder, here creates a room, including a living room, a kitchen, a bathroom, and a bedroom, a total of four rooms such as a house.

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. Inherit the IHouse interface, and the specific builder creates a house here, which only includes a bedroom, a living room, and a kitchen, a total of three rooms.

/// <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. Create a guide to guide which builder to build what kind of room.

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

5. Create:

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();
}

The builder pattern is mainly used to "build a complex object step by step", where "step by step" is a stable algorithm, and complex objects The various parts of the product often change

The product does not require abstract classes, especially when this pattern is used due to the complexity of the algorithm for creating objects or when this pattern is applied to the generation process of the product, the final result may vary greatly, not much It is possible to refine an abstract product class.

The previous abstract factory pattern solves the demand changes of "series objects", and the Builder pattern solves the demand changes of "object parts".

The use of builder pattern allows the internal appearance of the product to be changed independently. Using the builder pattern allows the client to avoid knowing the details of the internal composition of the product. Each Builder is relatively independent and has nothing to do with other Builders.

The builder pattern is suitable for properties of product objects that need to be generated. The builder pattern can force the generation order. The product objects that need to be generated have complex internal structures.