What are the benefits of the Test Data Builder pattern over Object Initializers? [closed]

Question

I've been reading a bunch of blog posts espousing the virtues of the Test Data Builder Pattern. It seems like a good idea, but all of the posts are years old.

When C# introduced Object Initializes, did it make the Test Data Builder pattern obsolete?

Before Object Initializers, you would have needed the following code to initialize a person object:

Person p = new Person("John", "Doe", "555-555-1234");

At the time, having a builder would have cleaned up the code like this:

Person person = new PersonBuilder()
        .WithFirstName("John")
        .WithLastName("Doe")
        .WithPhoneNumber("555-555-1234");

Now with object initializers, it can look like this without writing any builder methods:

Person p = new Person() {FirstName="John", LastName="Doe", Phone="555-555-1234"};

In this simple example, it would seem that the builder pattern is not needed. Am I missing something? Do people still use the builder pattern? If so, what are the benefits?

Answer 1

In many cases you can replace builders with object initializers.

However, there are a few cases where builders are still a good option.

Immutable objects is one example. e.g. Jon Skeets protobuff implementation is a good example of real world builder pattern for immutable objects. (https://codeblog.jonskeet.uk/2008/08/20/lessons-learned-from-protocol-buffers-part-1-messages-builders-and-immutability/)

Person john = new Person.Builder()
    .SetFirstName("John")
    .SetLastName("Doe")
    .Build(); //creates an immutable person

Other cases might be to apply preset values. eg.

Rectangle rect = RectangleBuilder.MakeSquare(10).Build();
Car car = CarBuilder.MakeVolvo().PimpIt().SetColor(Color.Red).Build();

In this case you might set multiple properties at once so you can start from a prototype of some sort and continue from there.