DummyBuilder records clone themselves on each step, for reuse.

Author: Timovzl

DomainModeling.Generator/DummyBuilderGenerator.cs

@@ -297,14 +297,15 @@ namespace {containingNamespace}
 	/// That way, if the constructor changes, only the builder needs to be adjusted, rather than lots of test methods.
 	/// </para>
 	/// </summary>
-	[CompilerGenerated] {type.DeclaredAccessibility.ToCodeString()} partial{(builder.IsRecord ? " record" : "")} class {typeName}
+	[CompilerGenerated] {type.DeclaredAccessibility.ToCodeString()} partial {(builder.IsRecord ? "record " : "")}class {typeName}
 	{{
 {joinedComponents}
 
 		private {typeName} With(Action<{typeName}> assignment)
 		{{
-			assignment(this);
-			return this;
+			var instance = this{(builder.IsRecord ? " with { }" : "")}; // If the type is a record, a copy is made, to enable reuse per step
+			assignment(instance);
+			return instance;
 		}}
 
 		{(hasBuildMethod ? "/*" : "")}

DomainModeling.Tests/DummyBuilderTests.cs

@@ -19,6 +19,29 @@ public void Build_Regularly_ShouldReturnExpectedResult()
 			Assert.Equal(1m, result.Amount.Amount.Value);
 		}
 
+		[Fact]
+		public void Build_WithReuseOfRecordTypedBuilder_ShouldReturnExpectedResult()
+		{
+			var builder = new TestEntityDummyBuilder()
+				.WithCount(5);
+
+			var result1 = builder
+				.WithCreationDate(DateOnly.FromDateTime(DateTime.UnixEpoch))
+				.Build();
+
+			var result2 = builder
+				.WithModificationDateTime(DateTime.UnixEpoch)
+				.Build();
+
+			Assert.Equal(5, result1.Count);
+			Assert.Equal(DateOnly.FromDateTime(DateTime.UnixEpoch), result1.CreationDate);
+			Assert.NotEqual(DateTime.UnixEpoch, result1.ModificationDateTime);
+
+			Assert.Equal(5, result2.Count);
+			Assert.NotEqual(DateOnly.FromDateTime(DateTime.UnixEpoch), result2.CreationDate);
+			Assert.Equal(DateTime.UnixEpoch, result2.ModificationDateTime);
+		}
+
 		[Fact]
 		public void Build_WithCustomizations_ShouldReturnExpectedResult()
 		{
@@ -62,7 +85,7 @@ public void Build_WithStringWrapperValueObject_ShouldUseEntityConstructorParamet
 	namespace DummyBuilderTestTypes
 	{
 		[DummyBuilder<TestEntity>]
-		public sealed partial class TestEntityDummyBuilder
+		public sealed partial record class TestEntityDummyBuilder
 		{
 			// Demonstrate that we can take priority over the generated members
 			public TestEntityDummyBuilder WithCreationDateTime(DateTime value) => this.With(b => b.CreationDateTime = value);

DomainModeling/DomainModeling.csproj

@@ -65,6 +65,7 @@ Misc:
 - Semi-breaking: IFormattable & co for string wrappers have stopped treating null strings as "", as this could cover up mistakes instead of revealing them.
 - Semi-breaking: IIdentity now implements IWrapperValueObject.
 - Feature: Non-generic Wrapper/Identity interfaces.
+- Feature: DummyBuilder records clone themselves on each step, for reuse.
 - Feature: Analyzer warns when '==' or similar operator implicitly casts some IValueObject to something else. This avoids accidentally comparing unrelated types.
 - Fix: Fixed bug where source-generated records would always generate ToString()/Equals()/GetHashCode(), even if you wrote your own.
 - Fix: Fixed bug where source-generated Wrappers/Identities would not recognize manual member implementations if they were explicit interface implementations.

README.md

@@ -227,7 +227,7 @@ The simple act of adding one property would require dozens of additional changes
 The Builder pattern fixes this problem:
 
 ```cs
-public class PaymentDummyBuilder
+public record class PaymentDummyBuilder
 {
 	// Have a default value for each property, along with a fluent method to change it
 
@@ -255,7 +255,7 @@ public class PaymentDummyBuilder
 }
 ```
 
-Test methods avoid constructor invocations, e.g. `new Payment("EUR", 1.00m)`, and instead use the following:
+Test methods can then avoid constructor invocations, e.g. `new Payment("EUR", 1.00m)`, and instead use the following:
 
 ```cs
 new PaymentBuilder().Build(); // Completely default instance
@@ -278,7 +278,7 @@ Change the type as follows to get source generation for it:
 
 ```cs
 [DummyBuilder<Payment>]
-public partial class PaymentDummyBuilder
+public partial record class PaymentDummyBuilder
 {
 	// Anything defined manually will cause the source generator to outcomment its conflicting code, i.e. manual code always takes precedence
 
@@ -294,6 +294,8 @@ The generated `Build()` method opts for _the most visible, simplest parameterize
 
 Dummy builders generally live in a test project, or in a library project consumed solely by test projects.
 
+Note that, if the dummy builder is a record class, a new copy is made on every mutation. This allows a partially constructed builder to be reused in multiple directions.
+
 ## Constructor Validation
 
 DDD promotes the validation of domain rules and invariants in the constructors of the domain objects. This pattern is fully supported: