Adds a Set overload which takes a lambda factory method

 - The specific use case for this is that we wanted to be able
   to use equivalence classes.  However, if you just use them naively,
   it would generate a single value and use it for all of the instances
   it created.
 - The lambda overload not only enables this case, but gives some power
   to constructing incrementing counters and the like.  For example,
   using a Queue to generate an ordered set of names, or other such use
   cases.

Author: Pi Lanningham

TestStack.Dossier.Tests/BuildTests.cs

@@ -1,4 +1,5 @@
-using Shouldly;
+using System.Collections.Generic;
+using Shouldly;
 using TestStack.Dossier.Tests.TestHelpers.Builders;
 using TestStack.Dossier.Tests.TestHelpers.Objects.Entities;
 using Xunit;
@@ -47,6 +48,32 @@ public void GivenBuilder_WhenCallingSetExplicitly_ShouldOverrideValues()
             customer.YearJoined.ShouldBe(2014);
         }
 
+        [Fact]
+        public void GivenBuilder_WhenCallingSetWithLambda_ShouldInvokeEachTime()
+        {
+            int counter = 2014;
+            var builder = new CustomerBuilder()
+                .Set(x => x.FirstName, "Pi")
+                .Set(x => x.LastName, "Lanningham")
+                .Set(x => x.YearJoined, () => counter++);
+
+            var customerA = builder.Build();
+            var customerB = builder.Build();
+
+            customerA.YearJoined.ShouldBe(2014);
+            customerB.YearJoined.ShouldBe(2015);
+
+            List<Customer> customerList = CustomerBuilder.CreateListOfSize(10)
+                                            .All()
+                                                .Set(x => x.YearJoined, () => counter++);
+            int newCounter = 2016;
+            foreach (var c in customerList)
+            {
+                c.YearJoined.ShouldBe(newCounter++);
+            }
+
+        }
+
         [Fact]
         public void GivenBasicBuilder_WhenCallingBuildImplicitly_ThenReturnAnObject()
         {

TestStack.Dossier/TestDataBuilder.cs

@@ -16,6 +16,7 @@ public abstract class TestDataBuilder<TObject, TBuilder>
         where TBuilder : TestDataBuilder<TObject, TBuilder>, new()
     {
         private readonly Dictionary<string, object> _properties = new Dictionary<string, object>(StringComparer.InvariantCultureIgnoreCase);
+        private readonly Dictionary<string, Func<object>> _propFactories = new Dictionary<string, Func<object>>();
         private ProxyBuilder<TObject> _proxyBuilder;
 
         /// <summary>
@@ -107,19 +108,32 @@ public TBuilder AsProxy()
         /// </summary>
         /// <param name="proxy">The proxy object</param>
         protected virtual void AlterProxy(TObject proxy) {}
-        
+
         /// <summary>
         /// Records the given value for the given property from {TObject} and returns the builder to allow chaining.
         /// </summary>
         /// <typeparam name="TValue">The type of the property</typeparam>
         /// <param name="property">A lambda expression specifying the property to record a value for</param>
-        /// <param name="value">The builder so that other method calls can be chained</param>
+        /// <param name="value">The value to set the property to</param>
+        /// <returns>The builder so that other method calls can be chained</returns>
         public virtual TBuilder Set<TValue>(Expression<Func<TObject, TValue>> property, TValue value)
         {
             _properties[Reflector.GetPropertyNameFor(property)] = value;
             return this as TBuilder;
         }
 
+        /// <summary>
+        /// Records a given value provider for the given property from {TObject} and returns the builder to allow chaining.
+        /// </summary>
+        /// <typeparam name="TValue">The type of the property</typeparam>
+        /// <param name="property">A lambda expression specifying the property to record a value for</param>
+        /// <param name="factory">A method which produces instances of {TValue} for the property.</param>
+        public virtual TBuilder Set<TValue>(Expression<Func<TObject, TValue>> property, Func<TValue> factory)
+        {
+            _propFactories[Reflector.GetPropertyNameFor(property)] = () => factory() as object;
+            return this as TBuilder;
+        }
+
         /// <summary>
         /// Gets the recorded value for the given property from {TObject} or an anonymous
         ///  value if there isn't one specified.
@@ -129,10 +143,7 @@ public virtual TBuilder Set<TValue>(Expression<Func<TObject, TValue>> property,
         /// <returns>The recorded value of the property or an anonymous value for it</returns>
         public TValue Get<TValue>(Expression<Func<TObject, TValue>> property)
         {
-            if (!Has(property))
-                return Any.Get(property);
-
-            return (TValue)_properties[Reflector.GetPropertyNameFor(property)];
+            return (TValue)Get(typeof (TValue), Reflector.GetPropertyNameFor(property));
         }
 
         /// <summary>
@@ -144,9 +155,13 @@ public TValue Get<TValue>(Expression<Func<TObject, TValue>> property)
         /// <returns></returns>
         public object Get(Type type, string propertyName)
         {
-            if (!Has(propertyName))
-                return Any.Get(type, propertyName);
-            return _properties[propertyName];
+            object value;
+            if (_properties.TryGetValue(propertyName, out value)) return value;
+
+            Func<object> factory;
+            if (_propFactories.TryGetValue(propertyName, out factory)) return factory();
+
+            return Any.Get(type, propertyName);
         } 
 
         /// <summary>
@@ -193,7 +208,7 @@ protected bool Has<TValue>(Expression<Func<TObject, TValue>> property)
         /// <returns>Whether or not there is a recorded value for the property</returns>
         protected bool Has(string propertyName)
         {
-            return _properties.ContainsKey(propertyName);
+            return _properties.ContainsKey(propertyName) || _propFactories.ContainsKey(propertyName);
         }
 
         /// <summary>