Fluent Builder Pattern

Fluent Builder Pattern in .NET Core

👤 Rohan Kumawat⏱️ 7 min read

What is the Fluent Builder Pattern?

The Fluent Builder Pattern in C# is a design pattern used to create complex objects step-by-step in a clean, readable, and chainable way. It makes your object creation code more expressive, less error-prone, and highly customizable.

Why Do We Use Fluent Builder? (Advantages)

It’s a combination of:

1️⃣ Builder Pattern
A pattern used to construct complex objects by separating the construction logic from the object itself.

2️⃣ Fluent Interface
A method-chaining style where each method returns the current object, enabling calls like:

builder.SetName("Rohan").SetAge(25).Build();

So Fluent Builder = Builder Pattern + Method Chaining.

Advantages of Fluent Builder

✔ More readable & expressive
Feels like natural language.

✔ Avoids telescoping constructors
No need for constructors like:

new User("Rohan", 25, "Jaipur", true, "Developer");

✔ Flexible object creation
You can set only the fields you need.

✔ Immutable or partially immutable objects
Useful in DDD, clean architecture, and API design.

✔ Guides the user during object creation
IntelliSense helps developers know what to call next.

Simple Example: Fluent Builder

Target object:

  
public class User  
{  
    public string Name { get; set; }  
    public int Age { get; set; }  
    public string City { get; set; }  
}  

Fluent Builder:

  
public class UserBuilder  
{  
    private readonly User _user = new();  

    public UserBuilder SetName(string name)  
    {  
        _user.Name = name;  
        return this;  
    }  

    public UserBuilder SetAge(int age)  
    {  
        _user.Age = age;  
        return this;  
    }  

    public UserBuilder FromCity(string city)  
    {  
        _user.City = city;  
        return this;  
    }  

    public User Build()  
    {  
        return _user;  
    }  
}  

Usage:

  
var user = new UserBuilder()  
                .SetName("Rohan")  
                .SetAge(25)  
                .FromCity("Jaipur")  
                .Build();  

Advanced Fluent Builder (Immutable + Validation)

Here’s a more advanced version, where the object is immutable and there's validation before building:

  
public class Order  
{  
    public string Product { get; }  
    public int Quantity { get; }  
    public string Address { get; }  

    private Order(string product, int quantity, string address)  
    {  
        Product = product;  
        Quantity = quantity;  
        Address = address;  
    }  

    public class Builder  
    {  
        private string _product;  
        private int _quantity;  
        private string _address;  

        public Builder ForProduct(string product)  
        {  
            _product = product;  
            return this;  
        }  

        public Builder WithQuantity(int quantity)  
        {  
            _quantity = quantity;  
            return this;  
        }  

        public Builder DeliverTo(string address)  
        {  
            _address = address;  
            return this;  
        }  

        public Order Build()  
        {  
            if (string.IsNullOrEmpty(_product))  
                throw new ArgumentException("Product cannot be empty");  

            return new Order(_product, _quantity, _address);  
        }  
    }  
}  

Usage:

  
var order = new Order.Builder()  
                 .ForProduct("Laptop")  
                 .WithQuantity(2)  
                 .DeliverTo("Jaipur")  
                 .Build();  

When to Use Fluent Builder

You should consider using the Fluent Builder Pattern when:

The object has many optional fields.
Object requires validation before creation.
You want to avoid constructor overloads.
You’re building complex configuration APIs.
You’re implementing Domain-Driven Design (DDD), CQRS, or Clean Architecture.