Question

I am reading Josh Bloch’s book Effective Java and he suggests using a builder design pattern when building objects that have large amounts of members. From what I can see it isn’t the vanilla design pattern but looks like his variation. I rather like the look of it and was trying to use it in a C# web application that I am writting. This is the code written in Java and works perfectly

public class Property {       private String title;     private String area;      private int sleeps = 0;      public static void main(String[] args) {          Property newProperty = new Property.Builder('Test Property').Area('Test Area').Sleeps(7).build();      }      private Property(Builder builder) {         this.title = builder.title;         this.area = builder.area;         this.sleeps =builder.sleeps;     }      public static class Builder{         private String title;         private String area;          private int sleeps = 0;          public Builder (String title){             this.title = title;         }          public Builder Area(String area){             this.area = area;             return this;         }          public Builder Sleeps(int sleeps){             this.sleeps = sleeps;             return this;         }          public Property build() {             return new Property(this);         }     }    } 

When I put this into what I think is the C# equivalent

 public class Property     {     private String title;     private String area;      private Property(Builder Builder)     {         title = Builder.title;         area = Builder.area;     }       public static class Builder     {         // Required parameters         private String title;         private String area;          // Optional parameters         private int sleeps = 0;          public Builder(String val)         {             this.title = val;         }          public Builder Area(String val)         {             this.area = val;             return this;         }          public Builder Sleeps(int val)         {             this.sleeps = val;             return this;         }          public Property build()         {             return new Property(this);         }     }     } 

Then I get compiler warnings. Most of them ‘cannot declare instance members in a static class’.

So my question is firstly what have I missed? If I have missed something, can I do it in the manner Josh Bloch recommends but in C#, and lastly, and this one important too, is this thread-safe?

Answer 1

I think you can achieve pretty much the same effect if you create Builder as a top level class ( for that’s exactly what it is in Java ) and create a factory method to receive the builder in order to keep the constructor private ( which in turn would let you return subclasses instances if needed).

The point is to let the builder perform the steps needed to create the object.

So ( without knowing much about C# you could try something like this )

// My naive C# attempt:P  public class Property  {      public static void main( String []args )      {          Property p = Property.buildFrom( new Builder('title').Area('area').Etc() )     }     public static Property buildFrom( Builder builder )      {         return new Propert( builder );     }      private Property ( Builder builder )      {         this.area = builder.area;         this.title = builder.title;         // etc.      } } public class Builder  {     public Builder ( String t )      {        this.title = t;     }      public Builder Area( String area )     {        this.area = area;        return this;     }     // etc.  } 

The whole point of having Builder as an static inner class of property is to create a high coupling among the two ( as if they where one ). That’s why build method in Builder calls the private ‘Property’ constructor.

Probably in C# you could use an alternate artifact to create the same coupling.