Feature: Allow for mapping properties containing periods

src/Mapster.Tests/WhenMappingMemberNameContainingPeriod.cs

@@ -0,0 +1,298 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.Runtime.CompilerServices;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Shouldly;
+
+namespace Mapster.Tests;
+
+[TestClass]
+public class WhenMappingMemberNameContainingPeriod
+{
+    private const string MemberName = "Some.Property.With.Periods";
+
+    [TestMethod]
+    public void Property_Name_Containing_Periods_Is_Supported()
+    {
+        // Create a target type with a property that contains periods
+        Type targetType = new TestTypeBuilder()
+            .AddProperty<int>(MemberName)
+            .CreateType();
+
+        // Call the local function defined below, the actual test method
+        CallStaticLocalTestMethod(
+            nameof(Test),
+            new Type[] { targetType });
+
+        // The actual test method adapting Source to the target type and back to the source to verify mapping the property with periods
+        static void Test<TTarget>()
+        {
+            // Get expression for mapping the property with periods
+            Expression<Func<TTarget, int>> getPropertyExpression = BuildGetPropertyExpression<TTarget, int>(MemberName);
+
+            // Create the config
+            TypeAdapterConfig<Source, TTarget>
+                .NewConfig()
+                .TwoWays()
+                .Map(getPropertyExpression, src => src.Value);
+
+            // Execute the mapping both ways
+            Source source = new() { Value = 551 };
+            TTarget target = source.Adapt<TTarget>();
+            Source adaptedSource = target.Adapt<Source>();
+
+            Assert.AreEqual(source.Value, adaptedSource.Value);
+        }
+    }
+
+    [TestMethod]
+    public void Constructor_Parameter_Name_Containing_Periods_Is_Supported()
+    {
+        // Create a target type with a property that contains periods
+        Type targetTypeWithProperty = new TestTypeBuilder()
+            .AddProperty<int>(MemberName)
+            .CreateType();
+
+        // Create a target type with a constructor parameter that contains periods
+        Type targetTypeWithConstructor = new TestTypeBuilder()
+            .AddConstructorWithReadOnlyProperty<int>(MemberName)
+            .CreateType();
+
+        // Call the local function defined below, the actual test method
+        CallStaticLocalTestMethod(
+            nameof(Test),
+            new Type[] { targetTypeWithProperty, targetTypeWithConstructor });
+
+        // The actual test method
+        static void Test<TWithProperty, TWithConstructor>()
+            where TWithProperty : new()
+        {
+            // Create the config
+            TypeAdapterConfig<TWithProperty, TWithConstructor>
+                .NewConfig()
+                .TwoWays()
+                .MapToConstructor(true);
+
+            // Create delegate for setting the property value on TWithProperty
+            Expression<Action<TWithProperty, int>> setPropertyExpression = BuildSetPropertyExpression<TWithProperty, int>(MemberName);
+            Action<TWithProperty, int> setProperty = setPropertyExpression.Compile();
+
+            // Create the source object
+            int value = 551;
+            TWithProperty source = new();
+            setProperty.Invoke(source, value);
+
+            // Map
+            TWithConstructor target = source.Adapt<TWithConstructor>();
+            TWithProperty adaptedSource = target.Adapt<TWithProperty>();
+
+            // Create delegate for getting the property from TWithProperty
+            Expression<Func<TWithProperty, int>> getPropertyExpression = BuildGetPropertyExpression<TWithProperty, int>(MemberName);
+            Func<TWithProperty, int> getProperty = getPropertyExpression.Compile();
+
+            // Verify
+            Assert.AreEqual(value, getProperty.Invoke(adaptedSource));
+        }
+    }
+
+    [TestMethod]
+    public void Using_Property_Path_String_Is_Supported()
+    {
+        // Create a target type with a property that contains periods
+        Type targetType = new TestTypeBuilder()
+            .AddProperty<int>(MemberName)
+            .CreateType();
+
+        // Create the config, both ways
+        TypeAdapterConfig
+            .GlobalSettings
+            .NewConfig(typeof(Source), targetType)
+            .Map(MemberName, nameof(Source.Value));
+        TypeAdapterConfig
+            .GlobalSettings
+            .NewConfig(targetType, typeof(Source))
+            .Map(nameof(Source.Value), MemberName);
+
+        // Execute the mapping both ways
+        Source source = new() { Value = 551 };
+        object target = source.Adapt(typeof(Source), targetType);
+        Source adaptedSource = target.Adapt<Source>();
+
+        Assert.AreEqual(source.Value, adaptedSource.Value);
+    }
+
+    [TestMethod]
+    public void Object_To_Dictionary_Map()
+    {
+        var poco = new SimplePoco
+        {
+            Id = Guid.NewGuid(),
+            Name = "test",
+        };
+
+        var config = new TypeAdapterConfig();
+        config.NewConfig<SimplePoco, Dictionary<string, object>>()
+            .Map(MemberName, c => c.Id);
+        var dict = poco.Adapt<Dictionary<string, object>>(config);
+
+        dict.Count.ShouldBe(2);
+        dict[MemberName].ShouldBe(poco.Id);
+        dict["Name"].ShouldBe(poco.Name);
+    }
+
+    private static void CallStaticLocalTestMethod(string methodName, Type[] genericArguments, [CallerMemberName] string caller = "Unknown")
+    {
+        MethodInfo genericMethodInfo = typeof(WhenMappingMemberNameContainingPeriod)
+            .GetMethods(BindingFlags.NonPublic | BindingFlags.Static)
+            .Single(x => x.Name.Contains($"<{caller}>") && x.Name.Contains(methodName));
+
+        MethodInfo method = genericMethodInfo.MakeGenericMethod(genericArguments);
+
+        method.Invoke(null, null);
+    }
+
+    private static Expression<Func<T, TProperty>> BuildGetPropertyExpression<T, TProperty>(string propertyName)
+    {
+        ParameterExpression param = Expression.Parameter(typeof(T), "x");
+        MemberExpression property = Expression.Property(param, propertyName);
+        return Expression.Lambda<Func<T, TProperty>>(property, param);
+    }
+
+    private static Expression<Action<T, TProperty>> BuildSetPropertyExpression<T, TProperty>(string propertyName)
+    {
+        ParameterExpression param = Expression.Parameter(typeof(T), "x");
+        ParameterExpression value = Expression.Parameter(typeof(TProperty), "value");
+        MemberExpression property = Expression.Property(param, propertyName);
+        BinaryExpression assign = Expression.Assign(property, value);
+        return Expression.Lambda<Action<T, TProperty>>(assign, param, value);
+    }
+
+    private class Source
+    {
+        public int Value { get; set; }
+    }
+
+    private class TestTypeBuilder
+    {
+        private readonly TypeBuilder _typeBuilder;
+
+        public TestTypeBuilder()
+        {
+            AssemblyBuilder assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(
+                new AssemblyName("Types"),
+                AssemblyBuilderAccess.Run);
+            ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("<Module>");
+            _typeBuilder = moduleBuilder.DefineType(
+                "Types.Target",
+                TypeAttributes.Public |
+                TypeAttributes.Class |
+                TypeAttributes.Sealed |
+                TypeAttributes.AutoClass |
+                TypeAttributes.AnsiClass |
+                TypeAttributes.BeforeFieldInit |
+                TypeAttributes.AutoLayout,
+                null);
+        }
+
+        public TestTypeBuilder AddConstructorWithReadOnlyProperty<TParameter>(string parameterName)
+        {
+            // Add read-only property
+            FieldBuilder fieldBuilder = AddProperty<TParameter>(parameterName, false);
+
+            // Build the constructor with the parameter for the property
+            ConstructorBuilder constructorBuilder = _typeBuilder.DefineConstructor(
+                MethodAttributes.Public,
+                CallingConventions.Standard,
+                new Type[] { typeof(TParameter) });
+
+            // Define the parameter name
+            constructorBuilder.DefineParameter(1, ParameterAttributes.None, MemberName);
+
+            ILGenerator constructorIL = constructorBuilder.GetILGenerator();
+
+            // Call the base class constructor
+            constructorIL.Emit(OpCodes.Ldarg_0);
+            constructorIL.Emit(OpCodes.Call, typeof(object).GetConstructor(Type.EmptyTypes));
+
+            // Set the property value
+            constructorIL.Emit(OpCodes.Ldarg_0);
+            constructorIL.Emit(OpCodes.Ldarg_1);
+            constructorIL.Emit(OpCodes.Stfld, fieldBuilder);
+
+            constructorIL.Emit(OpCodes.Ret);
+
+            return this;
+        }
+
+        public TestTypeBuilder AddProperty<T>(string propertyName)
+        {
+            AddProperty<T>(propertyName, true);
+            return this;
+        }
+
+        private FieldBuilder AddProperty<T>(string propertyName, bool addSetter)
+        {
+            Type propertyType = typeof(T);
+            FieldBuilder fieldBuilder = _typeBuilder.DefineField($"_{propertyName}", propertyType, FieldAttributes.Private);
+            PropertyBuilder propertyBuilder = _typeBuilder.DefineProperty(propertyName, PropertyAttributes.None, propertyType, null);
+
+            AddGetMethod(_typeBuilder, propertyBuilder, fieldBuilder, propertyName, propertyType);
+            if (addSetter)
+            {
+                AddSetMethod(_typeBuilder, propertyBuilder, fieldBuilder, propertyName, propertyType);
+            }
+
+            return fieldBuilder;
+        }
+
+        public Type CreateType() => _typeBuilder.CreateType();
+
+        private static PropertyBuilder AddGetMethod(TypeBuilder typeBuilder, PropertyBuilder propertyBuilder, FieldBuilder fieldBuilder, string propertyName, Type propertyType)
+        {
+            MethodBuilder getMethodBuilder = typeBuilder.DefineMethod(
+                "get_" + propertyName,
+                MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig,
+                propertyType,
+                Type.EmptyTypes);
+            ILGenerator getMethodGenerator = getMethodBuilder.GetILGenerator();
+
+            getMethodGenerator.Emit(OpCodes.Ldarg_0);
+            getMethodGenerator.Emit(OpCodes.Ldfld, fieldBuilder);
+            getMethodGenerator.Emit(OpCodes.Ret);
+
+            propertyBuilder.SetGetMethod(getMethodBuilder);
+
+            return propertyBuilder;
+        }
+
+        private static PropertyBuilder AddSetMethod(TypeBuilder typeBuilder, PropertyBuilder propertyBuilder, FieldBuilder fieldBuilder, string propertyName, Type propertyType)
+        {
+            MethodBuilder setMethodBuilder = typeBuilder.DefineMethod(
+                $"set_{propertyName}",
+                MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig,
+                null,
+                new Type[] { propertyType });
+
+            ILGenerator setMethodGenerator = setMethodBuilder.GetILGenerator();
+            Label modifyProperty = setMethodGenerator.DefineLabel();
+            Label exitSet = setMethodGenerator.DefineLabel();
+
+            setMethodGenerator.MarkLabel(modifyProperty);
+            setMethodGenerator.Emit(OpCodes.Ldarg_0);
+            setMethodGenerator.Emit(OpCodes.Ldarg_1);
+            setMethodGenerator.Emit(OpCodes.Stfld, fieldBuilder);
+
+            setMethodGenerator.Emit(OpCodes.Nop);
+            setMethodGenerator.MarkLabel(exitSet);
+            setMethodGenerator.Emit(OpCodes.Ret);
+
+            propertyBuilder.SetSetMethod(setMethodBuilder);
+
+            return propertyBuilder;
+        }
+    }
+}

src/Mapster.Tool/Program.cs

@@ -76,7 +76,7 @@ private static void GenerateMappers(MapperOptions opt)
             // This way when we compare attribute types (such as MapperAttribute) between our running assembly
             // and the scanned assembly the two types with the same FullName can be considered equal because
             // they both were resolved from AssemblyLoadContext.Default.
-            
+
             // This isolated Assembly Load Context will be able to resolve the Mapster assembly, but
             // the resolved Assembly will be the same one that is in AssemblyLoadContext.Default
             // (the runtime assembly load context that our code refers to by default when referencing
@@ -461,8 +461,8 @@ Dictionary<string, PropertySetting> settings
                     setter.Settings.Resolvers.Add(
                         new InvokerModel
                         {
-                            DestinationMemberName = setting.TargetPropertyName ?? name,
-                            SourceMemberName = name,
+                            DestinationMemberPath = (setting.TargetPropertyName ?? name).Split('.'),
+                            SourceMemberPath = name.Split('.'),
                             Invoker = setting.MapFunc,
                         }
                     );

src/Mapster/Adapters/BaseClassAdapter.cs

@@ -26,7 +26,7 @@ protected ClassMapping CreateClassConverter(Expression source, ClassModel classM
                 arg.Settings.ExtraSources.Select(src =>
                     src is LambdaExpression lambda 
                         ? lambda.Apply(arg.MapType, source) 
-                        : ExpressionEx.PropertyOrFieldPath(source, (string)src)));
+                        : ExpressionEx.PropertyOrFieldPath(source, (string[])src)));
             foreach (var destinationMember in destinationMembers)
             {
                 if (ProcessIgnores(arg, destinationMember, out var ignore))
@@ -124,7 +124,7 @@ protected static bool ProcessIgnores(
             if (!destinationMember.ShouldMapMember(arg, MemberSide.Destination))
                 return true;
 
-            return arg.Settings.Ignore.TryGetValue(destinationMember.Name, out ignore)
+            return arg.Settings.Ignore.TryGetValue(new[] { destinationMember.Name }, out ignore)
                    && ignore.Condition == null;
         }
 

src/Mapster/Adapters/ClassAdapter.cs

@@ -214,7 +214,9 @@ private static Expression SetValueByReflection(MemberMapping member, MemberExpre
                 if (member.UseDestinationValue)
                     return null;
 
-                if (!arg.Settings.Resolvers.Any(r => r.DestinationMemberName == member.DestinationMember.Name) 
+                if (!arg.Settings.Resolvers.Any(r
+                        => r.DestinationMemberPath.Length == 1
+                        && r.DestinationMemberPath[0] == member.DestinationMember.Name)
                     && member.Getter is MemberExpression memberExp && contructorMembers.Contains(memberExp.Member))
                     continue;
 

src/Mapster/Adapters/DictionaryAdapter.cs

@@ -105,16 +105,17 @@ protected override Expression CreateBlockExpression(Expression source, Expressio
 
             //ignore mapped
             var ignores = arg.Settings.Resolvers
-                .Select(r => r.SourceMemberName)
-                .Where(name => name != null)
+                .Select(r => r.SourceMemberPath)
+                .Where(path => path != null)
+                .Select(path => path![0])
                 .ToHashSet();
 
             //ignore
             var ignoreIfs = new Dictionary<string, Expression>();
             foreach (var ignore in arg.Settings.Ignore)
             {
                 if (ignore.Value.Condition == null)
-                    ignores.Add(ignore.Key);
+                    ignores.Add(ignore.Key[0]);
                 else
                 {
                     var body = ignore.Value.IsChildPath
@@ -123,7 +124,7 @@ protected override Expression CreateBlockExpression(Expression source, Expressio
                     var setWithCondition = Expression.IfThen(
                         ExpressionEx.Not(body),
                         set);
-                    ignoreIfs.Add(ignore.Key, setWithCondition);
+                    ignoreIfs.Add(ignore.Key[0], setWithCondition);
                 }
             }
 

src/Mapster/Adapters/RecordTypeAdapter.cs

@@ -69,7 +69,9 @@ protected override Expression CreateInlineExpression(Expression source, CompileA
                 if (member.UseDestinationValue)
                     return null;
 
-                if (!arg.Settings.Resolvers.Any(r => r.DestinationMemberName == member.DestinationMember.Name)
+                if (!arg.Settings.Resolvers.Any(r
+                        => r.DestinationMemberPath.Length == 1
+                        && r.DestinationMemberPath[0] == member.DestinationMember.Name)
                     && member.Getter is MemberExpression memberExp && contructorMembers.Contains(memberExp.Member))
                     continue;