Another way to implement the builder pattern is with fluent builder. Fluent builder provides a more readable and straightforward way to create objects. The pattern is implemented by having a series of methods that return the builder type itself and a build method that returns an instance of the class we are building.
For our example we are going to create a Desktop PC builder.
Bellow is the sample code:
public interface IDesktopBuilder
{
IDesktopBuilder WithCase(string @case);
IDesktopBuilder WithCpu(string cpu);
IDesktopBuilder WithMotherBoard(string motherboard);
IDesktopBuilder WithVideoCard(string videoCard);
IDesktopBuilder WithOperatingSystem(string operatingSystem);
Desktop Build();
}
public class DesktopBuilder : IDesktopBuilder
{
private readonly Desktop _desktop;
public DesktopBuilder()
{
_desktop = new Desktop();
}
public IDesktopBuilder WithCase(string @case)
{
_desktop.Case = @case;
return this;
}
public IDesktopBuilder WithCpu(string cpu)
{
_desktop.Cpu = cpu;
return this;
}
public IDesktopBuilder WithMotherBoard(string motherboard)
{
_desktop.Motherboard = motherboard;
return this;
}
public IDesktopBuilder WithVideoCard(string videoCard)
{
_desktop.VideoCard = videoCard;
return this;
}
public IDesktopBuilder WithOperatingSystem(string operatingSystem)
{
_desktop.OperatingSystem = operatingSystem;
return this;
}
public Desktop Build()
{
return _desktop;
}
}
public class DesktopPc
{
public string Case { get; set; }
public string Motherboard { get; set; }
public string Cpu { get; set; }
public string VideoCard { get; set; }
public string OperatingSystem { get; set; }
}
Finally we can create a Desktop PC by using the fluent builder by the following way
DesktopPc desktop = new DesktopBuilder()
.WithCase("Mini Tower Case")
.WithCpu("3.6Ghz 12 cores")
.WithMotherBoard("Gaming board")
.WithVideoCard("Gaming v3 12GB")
.WithOperatingSystem("64bit OS")
.Build();
Or if we do not want to add an Operating System in our Desktop setup
DesktopPc desktop = new DesktopBuilder()
.WithCase("Mini Tower Case")
.WithCpu("3.6Ghz 12 cores")
.WithMotherBoard("Gaming board")
.WithVideoCard("Gaming v3 12GB")
.Build();
Progressive Builder (progressive interface)
Although the fluent builder pattern gives us a more readable way to create an object, there is a drawback with the above approach. We can't tie the way we construct the object, for example if there is a need to select motherboard before adding a CPU. Also even though we have already used a method, this method remains available and we can use it again as shown in the image bellow.
To achieve such a behavior we can utilize the Progressive Builder pattern. With progressive interface we can use multiple builder patterns in a sequential way. This allow us to chain in a fixed sequence the method calls. The advantage of this implementation is that we ensure that the object is built in the correct order.
For example we want to build a desktop pc but in the following order.
- Select a case
- Select a motherboard
- Select a CPU
- Select a video card
- Select operating system
For this to be done we will create separate interface for each desktop property and everyone of them is going to have a returning type the interface that comes next in the chain.
Bellow is the sample code:
public interface IProgressiveBuilder
{
ICaseBuilder WithCase(string @case);
}
public interface ICaseBuilder
{
IMotherboardBuilder WithMotherboard(string motherboard);
}
public interface IMotherboardBuilder
{
ICpuBuilder WithCpu(string cpu);
}
public interface ICpuBuilder
{
IVideoCardBuilder WithVideoCard(string videoCard);
}
public interface IVideoCardBuilder
{
IOperatingSystemBuilder WithOperatingSystem(string operatingSystem);
}
public interface IOperatingSystemBuilder
{
ProgressiveDesktop Create();
}
public class ProgressiveDesktop :
IProgressiveBuilder,
ICaseBuilder,
IMotherboardBuilder,
ICpuBuilder,
IVideoCardBuilder,
IOperatingSystemBuilder
{
public string Case;
public string Motherboard;
public string Cpu;
public string VideoCard;
public string OperatingSystem;
// Keep constructor private to avoid
// instantiation of the class outside of the builder
private ProgressiveDesktop()
{
}
public static IProgressiveBuilder Build()
{
return new ProgressiveDesktop();
}
public ICaseBuilder WithCase(string @case)
{
Case = @case;
return this;
}
public IMotherboardBuilder WithMotherboard(string motherboard)
{
Motherboard = motherboard;
return this;
}
public ICpuBuilder WithCpu(string cpu)
{
Cpu = cpu;
return this;
}
public IVideoCardBuilder WithVideoCard(string videoCard)
{
VideoCard = videoCard;
return this;
}
public IOperatingSystemBuilder WithOperatingSystem(string operatingSystem)
{
OperatingSystem = operatingSystem;
return this;
}
public ProgressiveDesktop Create()
{
return this;
}
}
// Build desktop object with the use of progressive builder
ProgressiveDesktop desktop = ProgressiveDesktop
.Build()
.WithCase("Mini Tower Case")
.WithMotherboard("Gaming board")
.WithCpu("3.6Ghz 12 cores")
.WithVideoCard("Gaming v3 12GB")
.WithOperatingSystem("64bit OS")
.Create();
Now when creating a progressive desktop the only available method is the Build.
Respectively the only available method after Build is the WithCase since this is the next in chain method.
Top comments (0)