DefaultSetter.cs - Enhanced member access logic to support properties and fields

Rule.cs - Improved member value retrieval and setting with better expression handling
Customer.cs - Added new dictionary-based address properties for testing

Author: Colin Wilmans

src/FluentDefaults/FluentDefaults.csproj

@@ -8,7 +8,7 @@
 		<Nullable>enable</Nullable>
 		<PackageId>FluentDefaults</PackageId>
 		<VersionSuffix Condition="'$(VersionSuffix)' == ''">0</VersionSuffix>
-		<Version>1.1.$(VersionSuffix)</Version>
+		<Version>1.2.$(VersionSuffix)</Version>
 		<Authors>Colin Wilmans</Authors>
 		<PackageDescription>A library for .NET that uses a fluent interface for setting default values, similar to how FluentValidation handles validations.</PackageDescription>
 		<RepositoryUrl>https://github.com/crwsolutions/fluent-defaults.git</RepositoryUrl>
@@ -22,7 +22,7 @@
 		<Description>A library for .NET that uses a fluent interface for setting defaults</Description>
 		<PackageReadmeFile>README.md</PackageReadmeFile>
 		<Title>Fluent Defaults</Title>
-		<PackageReleaseNotes>Add check for collections with deferred execution. Added extension methods for chaining</PackageReleaseNotes>
+		<PackageReleaseNotes>Improved member value retrieval and setting with better expression handling. This also results in support for Dictionaries</PackageReleaseNotes>
 		<GenerateDocumentationFile>true</GenerateDocumentationFile>
 	</PropertyGroup>
 

src/FluentDefaults/Rule.cs

@@ -21,40 +21,89 @@ internal sealed class Rule<T>
 
     private TElementProperty? GetChildValue<TProperty, TElementProperty>(TProperty element)
     {
-        return (TElementProperty?)(ChildMemberExpression!.Member as PropertyInfo)?.GetGetMethod()?.Invoke(element, null);
+        var (target, member) = GetTargetAndMember(ChildMemberExpression!, element);
+
+        return member switch
+        {
+            PropertyInfo prop => (TElementProperty?)prop.GetValue(target),
+            FieldInfo field => (TElementProperty?)field.GetValue(target),
+            _ => throw new Exception("Unsupported member type")
+        };
     }
 
-    private void SetChildValue<TProperty, TElementProperty>(TProperty element, TElementProperty? defaultValue)
+    private void SetChildValue<TProperty, TElementProperty>(TProperty element, TElementProperty? value)
     {
-        (ChildMemberExpression!.Member as PropertyInfo)?.GetSetMethod()?.Invoke(element, [defaultValue]);
+        var (target, member) = GetTargetAndMember(ChildMemberExpression!, element);
+
+        switch (member)
+        {
+            case PropertyInfo prop:
+                prop.GetSetMethod()?.Invoke(target, [value]);
+                break;
+            case FieldInfo field:
+                field.SetValue(target, value);
+                break;
+            default:
+                throw new Exception("Unsupported member type");
+        }
     }
 
     internal TProperty? GetMemberValue<TProperty>(T instance)
     {
-        return MemberExpression.Member switch
+        var (target, member) = GetTargetAndMember(MemberExpression, instance);
+        return member switch
         {
-            PropertyInfo propertyInfo => (TProperty?)propertyInfo.GetGetMethod()?.Invoke(instance, null),
-            FieldInfo fieldInfo => (TProperty?)fieldInfo.GetValue(instance),
+            PropertyInfo prop => (TProperty?)prop.GetValue(target),
+            FieldInfo field => (TProperty?)field.GetValue(target),
             _ => throw new Exception("Unsupported member type")
         };
     }
 
-    private void SetMemberValue<TProperty>(T instance, TProperty? defaultValue)
+    private void SetMemberValue<TProperty>(T instance, TProperty? value)
     {
-        if (MemberExpression.Member is PropertyInfo propertyInfo)
+        var (target, member) = GetTargetAndMember(MemberExpression, instance);
+        switch (member)
         {
-            propertyInfo.GetSetMethod()?.Invoke(instance, [defaultValue]);
+            case PropertyInfo prop:
+                prop.GetSetMethod()?.Invoke(target, [value]);
+                break;
+            case FieldInfo field:
+                field.SetValue(target, value);
+                break;
+            default:
+                throw new Exception("Member is not a Property or Field");
         }
-        else if (MemberExpression.Member is FieldInfo fieldInfo)
+    }
+
+
+    private static (object? target, MemberInfo member) GetTargetAndMember(Expression memberExpression, object? instance)
+    {
+        object? current = instance;
+        var stack = new Stack<MemberExpression>();
+
+        Expression? expr = memberExpression;
+        while (expr is MemberExpression m)
         {
-            fieldInfo.SetValue(instance, defaultValue);
+            stack.Push(m);
+            expr = m.Expression;
         }
-        else
+
+        while (stack.Count > 1)
         {
-            throw new Exception("Member is not a Property or Field");
+            var m = stack.Pop();
+            current = m.Member switch
+            {
+                PropertyInfo prop => prop.GetValue(current),
+                FieldInfo field => field.GetValue(current),
+                _ => throw new Exception("Unsupported member type")
+            };
         }
+
+        var lastMember = stack.Pop();
+        return (current, lastMember.Member);
     }
 
+
     internal MemberExpression? ChildMemberExpression { get; set; }
 
     internal Rule(MemberExpression memberExpression)

tests/FluentDefaults.Tests/DictionaryDefaultForTests.cs

@@ -0,0 +1,81 @@
+using FluentDefaults.Tests.Model;
+
+namespace FluentDefaults.Tests;
+
+public class DictionaryDefaultForTests
+{
+    [Fact]
+    public void DictionaryWithDefaulter_ShouldGetThatDefault()
+    {
+        var customer = new Customer();
+        var defaulter = new DictionaryCustomerWithDefaulterDefaulter();
+
+        defaulter.Apply(customer);
+
+        Assert.Equal("Default Street", customer.Addresses4["key1"].Street);
+        Assert.Equal("Default City", customer.Addresses4["key1"].City);
+        Assert.Equal("Street 1", customer.Addresses5["key1"].Street);
+    }
+
+    [Fact]
+    public void DictionaryWithDefaultFor_ShouldGetThatDefault()
+    {
+        var customer = new Customer();
+        var defaulter = new DictionaryCustomerWithDefaultForDefaulter();
+
+        defaulter.Apply(customer);
+        var numberedAddresses = customer.Addresses5;
+
+        Assert.Equal("- unknown city -", customer.Addresses5.First().Value.City);
+        Assert.Equal("- unknown street -", customer.Addresses5.First().Value.Street);
+        Assert.Equal(1, numberedAddresses["key1"].Id);
+        Assert.Equal(2, numberedAddresses["key2"].Id);
+        Assert.Equal(3, numberedAddresses["key3"].Id);
+        Assert.Equal("5 street", customer.Addresses4.First().Value.Street);
+    }
+}
+
+internal sealed class DictionaryAddressDefaulter : AbstractDefaulter<KeyValuePair<string, Address>>
+{
+    internal DictionaryAddressDefaulter()
+    {
+        DefaultFor(x => x.Value.Street).Is("Default Street");
+        DefaultFor(x => x.Value.City).Is("Default City");
+    }
+}
+
+internal sealed class DictionaryAddressDefaulterWithParameter : AbstractDefaulter<KeyValuePair<string, Address>>
+{
+    internal DictionaryAddressDefaulterWithParameter(Customer customer)
+    {
+        DefaultFor(x => x.Value.Street).Is($"Street {customer.Number1}");
+    }
+}
+
+internal sealed class DictionaryCustomerWithDefaulterDefaulter : AbstractDefaulter<Customer>
+{
+    internal DictionaryCustomerWithDefaulterDefaulter()
+    {
+        DefaultFor(x => x.Number1).Is(1);
+        ForEach(x => x.Addresses4).SetDefaulter(new DictionaryAddressDefaulter());
+        ForEach(x => x.Addresses5).SetDefaulter((x) => new DictionaryAddressDefaulterWithParameter(x));
+    }
+}
+
+internal sealed class DictionaryCustomerWithDefaultForDefaulter : AbstractDefaulter<Customer>
+{
+    int _number = 0;
+
+    internal DictionaryCustomerWithDefaultForDefaulter()
+    {
+        ForEach(x => x.Addresses5).DefaultFor(x => x.Value.City).Is("- unknown city -");
+        ForEach(x => x.Addresses5).DefaultFor(x => x.Value.Street).Is(() => "- unknown street -");
+        ForEach(x => x.Addresses5).DefaultFor(x => x.Value.Id).Is(GetNumber);
+        ForEach(x => x.Addresses4).DefaultFor(x => x.Value.Street).Is(GetSome);
+    }
+
+    private string GetSome(Customer x) => $"{x.Number5} street";
+
+    private int GetNumber() => ++_number;
+}
+

tests/FluentDefaults.Tests/Model/Customer.cs

@@ -13,6 +13,19 @@ internal sealed class Customer
     public Address[] Addresses1 { get; set; } = [new Address()];
     public List<Address> Addresses2 { get; set; } = [new Address(), new Address(), new Address()];
     public Address[] Addresses3 { get; set; } = [new Address()];
+    public Dictionary<string, Address> Addresses4 { get; set; } = new Dictionary<string, Address>
+    {
+        { "key1", new Address() },
+        { "key2", new Address() },
+        { "key3", new Address() }
+    };
+
+    public Dictionary<string, Address> Addresses5 { get; set; } = new Dictionary<string, Address>
+    {
+        { "key1", new Address() },
+        { "key2", new Address() },
+        { "key3", new Address() }
+    };
 
     public Address Address1 { get; set; } = new Address();
     public Address Address2 { get; set; } = default!;