Add Builder Pattern implementation and tests

Author: froghramar

DesignPatterns/Builder/House.cs

@@ -0,0 +1,21 @@
+namespace DesignPatterns.Builder;
+
+public sealed class House
+{
+    public int Rooms { get; }
+    public int Windows { get; }
+    public bool HasGarage { get; }
+    public string Address { get; }
+
+    public House(int rooms, int windows, bool hasGarage, string address)
+    {
+        if (rooms < 0) throw new ArgumentOutOfRangeException(nameof(rooms));
+        if (windows < 0) throw new ArgumentOutOfRangeException(nameof(windows));
+        Address = address ?? string.Empty;
+        Rooms = rooms;
+        Windows = windows;
+        HasGarage = hasGarage;
+    }
+
+    public override string ToString() => $"House: {Rooms} rooms, {Windows} windows, Garage: {HasGarage}, Address: {Address}";
+}

DesignPatterns/Builder/HouseBuilder.cs

@@ -0,0 +1,38 @@
+namespace DesignPatterns.Builder;
+
+public class HouseBuilder
+{
+    private int _rooms;
+    private int _windows;
+    private bool _hasGarage;
+    private string _address = string.Empty;
+
+    public HouseBuilder WithRooms(int rooms)
+    {
+        _rooms = rooms;
+        return this;
+    }
+
+    public HouseBuilder WithWindows(int windows)
+    {
+        _windows = windows;
+        return this;
+    }
+
+    public HouseBuilder WithGarage(bool hasGarage = true)
+    {
+        _hasGarage = hasGarage;
+        return this;
+    }
+
+    public HouseBuilder AtAddress(string address)
+    {
+        _address = address ?? string.Empty;
+        return this;
+    }
+
+    public House Build()
+    {
+        return new House(_rooms, _windows, _hasGarage, _address);
+    }
+}

DesignPatterns/Program.cs

@@ -1,5 +1,6 @@
 using DesignPatterns.Factories;
 using DesignPatterns.Singleton;
+using DesignPatterns.Builder;
 
 Console.WriteLine("Factory pattern demo:");
 
@@ -11,14 +12,24 @@
 Console.WriteLine(square.Draw());
 Console.WriteLine(rect.Draw());
 
+// Builder demo
+var house = new HouseBuilder()
+    .WithRooms(3)
+    .WithWindows(5)
+    .WithGarage()
+    .AtAddress("123 Main St")
+    .Build();
+
+Console.WriteLine();
+Console.WriteLine("Builder pattern demo:");
+Console.WriteLine(house.ToString());
+
 // Singleton demo
 Logger.Instance.Clear();
-Logger.Instance.Log("Application started");
-Logger.Instance.Log(circle.Draw());
-Logger.Instance.Log(square.Draw());
-Logger.Instance.Log(rect.Draw());
-Logger.Instance.Log("Application finished");
+Logger.Instance.Log("Singleton started");
+Logger.Instance.Log("Singleton finished");
 
+Console.WriteLine();
 Console.WriteLine("Logged messages:");
 foreach (var msg in Logger.Instance.Messages)
 {

README.md

@@ -3,10 +3,49 @@ Design Patterns Examples
 This solution demonstrates simple design pattern examples in C# targeting .NET 10 (C# 14).
 
 Projects
-- `DesignPatterns` - Console demo showing Factory and Singleton patterns.
+- `DesignPatterns` - Console demo showing Factory, Singleton, and Builder patterns.
   - Factory implementation: `DesignPatterns/Factories`
   - Singleton implementation: `DesignPatterns/Singleton/Logger.cs`
-- `Tests` - xUnit tests covering the factory and singleton examples.
+  - Builder implementation: `DesignPatterns/Builder/HouseBuilder.cs` and `DesignPatterns/Builder/House.cs`
+- `Tests` - xUnit tests covering the examples.
+
+Included patterns and brief docs
+
+- Factory Pattern
+  - Purpose: Encapsulates object creation and returns different concrete implementations via a common interface.
+  - Example: `DesignPatterns/Factories/ShapeFactory.cs` creates `Circle`, `Square`, or `Rectangle` based on `ShapeType`.
+
+- Singleton Pattern
+  - Purpose: Ensures a class has only one instance and provides a global point of access.
+  - Example: `DesignPatterns/Singleton/Logger.cs` — thread-safe singleton using `System.Lazy<T>` and `System.Collections.Concurrent.ConcurrentQueue<string>` to store log messages.
+  - Usage snippet:
+
+    ```csharp
+    var logger = Logger.Instance;
+    logger.Clear();
+    logger.Log("Application started");
+    foreach (var msg in Logger.Instance.Messages) Console.WriteLine(msg);
+    ```
+
+- Builder Pattern
+  - Purpose: Separates the construction of a complex object from its representation, providing a fluent API for step-by-step creation.
+  - Example: `DesignPatterns/Builder/HouseBuilder.cs` builds immutable `House` instances from `DesignPatterns/Builder/House.cs`.
+  - Usage snippet:
+
+    ```csharp
+    var house = new HouseBuilder()
+        .WithRooms(3)
+        .WithWindows(5)
+        .WithGarage()
+        .AtAddress("123 Main St")
+        .Build();
+    ```
+
+Tests
+- Tests are written with xUnit in the `Tests` project.
+  - Factory tests: `Tests/ShapeFactoryTests.cs`
+  - Singleton tests: `Tests/SingletonTests.cs`
+  - Builder tests: `Tests/BuilderTests.cs`
 
 Requirements
 - .NET 10 SDK
@@ -17,5 +56,5 @@ Common commands
 - Run tests: `dotnet test`
 
 Notes
-- The `Logger` singleton is thread-safe and uses `System.Lazy<T>` with a `ConcurrentQueue<string>` to store messages.
-- Tests are located in the `Tests` project; see `Tests/ShapeFactoryTests.cs` and `Tests/SingletonTests.cs`.
+- The examples are intentionally small to demonstrate the patterns and are suitable as learning references.
+- The `Logger` singleton is implemented to be safe for concurrent use in tests and examples.

Tests/BuilderTests.cs

@@ -0,0 +1,33 @@
+using DesignPatterns.Builder;
+
+namespace Tests;
+
+public class BuilderTests
+{
+    [Fact]
+    public void HouseBuilder_BuildsHouseWithSpecifiedProperties()
+    {
+        var house = new HouseBuilder()
+            .WithRooms(3)
+            .WithWindows(5)
+            .WithGarage()
+            .AtAddress("123 Main St")
+            .Build();
+
+        Assert.Equal(3, house.Rooms);
+        Assert.Equal(5, house.Windows);
+        Assert.True(house.HasGarage);
+        Assert.Equal("123 Main St", house.Address);
+    }
+
+    [Fact]
+    public void HouseBuilder_DefaultsWhenNotSpecified()
+    {
+        var house = new HouseBuilder().Build();
+
+        Assert.Equal(0, house.Rooms);
+        Assert.Equal(0, house.Windows);
+        Assert.False(house.HasGarage);
+        Assert.Equal(string.Empty, house.Address);
+    }
+}