Allow properties or fields to contain periods

Author: JMolenkamp

src/Mapster/Utils/ExpressionEx.cs

@@ -1,8 +1,9 @@
-using System.Linq.Expressions;
-using System;
+using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
+using System.Linq.Expressions;
 using System.Reflection;
 
 namespace Mapster.Utils
@@ -19,32 +20,112 @@ public static Expression Assign(Expression left, Expression right)
 
         public static Expression PropertyOrFieldPath(Expression expr, string path)
         {
-            var props = path.Split('.');
-            return props.Aggregate(expr, PropertyOrField);
+            Expression current = expr;
+            string[] props = path.Split('.');
+
+            for (int i = 0; i < props.Length; i++)
+            {
+                if (IsDictionaryKey(current, props[i], out Expression? next))
+                {
+                    current = next;
+                    continue;
+                }
+
+                if (IsPropertyOrField(current, props[i], out next))
+                {
+                    current = next;
+                    continue;
+                }
+
+                // For dynamically built types, it is possible to have periods in the property name.
+                // Rejoin an incrementing number of parts with periods to try and find a property match. 
+                if (IsPropertyOrFieldPathWithPeriods(current, props[i..], out next, out int combinationLength))
+                {
+                    current = next;
+                    i += combinationLength - 1;
+                    continue;
+                }
+
+                throw new ArgumentException($"'{props[i]}' is not a member of type '{current.Type.FullName}'", nameof(path));
+            }
+
+            return current;
         }
 
-        private static Expression PropertyOrField(Expression expr, string prop)
+        private static bool IsPropertyOrFieldPathWithPeriods(Expression expr, string[] path, [NotNullWhen(true)] out Expression? propExpr, out int combinationLength)
+        {
+            if (path.Length < 2)
+            {
+                propExpr = null;
+                combinationLength = 0;
+                return false;
+            }
+
+            for (int count = 2; count <= path.Length; count++)
+            {
+                string prop = string.Join('.', path[..count]);
+                if (IsPropertyOrField(expr, prop, out propExpr))
+                {
+                    combinationLength = count;
+                    return true;
+                }
+            }
+
+            propExpr = null;
+            combinationLength = 0;
+            return false;
+        }
+
+        private static bool IsDictionaryKey(Expression expr, string prop, [NotNullWhen(true)] out Expression? propExpr)
         {
             var type = expr.Type;
             var dictType = type.GetDictionaryType();
-            if (dictType?.GetGenericArguments()[0] == typeof(string))
-            {
-                var method = typeof(MapsterHelper).GetMethods()
-                    .First(m => m.Name == nameof(MapsterHelper.GetValueOrDefault) && m.GetParameters()[0].ParameterType.Name == dictType.Name)
-                    .MakeGenericMethod(dictType.GetGenericArguments());
 
-                return Expression.Call(method, expr.To(type), Expression.Constant(prop));
+            if (dictType?.GetGenericArguments()[0] != typeof(string))
+            {
+                propExpr = null;
+                return false;
             }
 
+            var method = typeof(MapsterHelper).GetMethods()
+                .First(m => m.Name == nameof(MapsterHelper.GetValueOrDefault) && m.GetParameters()[0].ParameterType.Name == dictType.Name)
+                .MakeGenericMethod(dictType.GetGenericArguments());
+
+            propExpr = Expression.Call(method, expr.To(type), Expression.Constant(prop));
+            return true;
+        }
+
+        private static bool IsPropertyOrField(Expression expr, string prop, [NotNullWhen(true)] out Expression? propExpr)
+        {
+            Type type = expr.Type;
+
             if (type.GetTypeInfo().IsInterface)
             {
                 var allTypes = type.GetAllInterfaces();
                 var flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
                 var interfaceType = allTypes.FirstOrDefault(it => it.GetProperty(prop, flags) != null || it.GetField(prop, flags) != null);
                 if (interfaceType != null)
+                {
                     expr = Expression.Convert(expr, interfaceType);
+                    type = expr.Type;
+                }
             }
-            return Expression.PropertyOrField(expr, prop);
+
+            MemberInfo? propertyOrField = type
+                .GetMember(
+                    prop,
+                    MemberTypes.Field | MemberTypes.Property,
+                    BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.FlattenHierarchy)
+                .FirstOrDefault();
+
+            propExpr = propertyOrField?.MemberType switch
+            {
+                MemberTypes.Property => Expression.Property(expr, (PropertyInfo)propertyOrField),
+                MemberTypes.Field => Expression.Field(expr, (FieldInfo)propertyOrField),
+                _ => null
+            };
+
+            return propExpr != null;
         }
 
         private static bool IsReferenceAssignableFrom(this Type destType, Type srcType)
@@ -136,14 +217,14 @@ public static Delegate Compile(this LambdaExpression exp, CompileArgument arg)
             if (source.Type.IsArray)
             {
                 return source.Type.GetArrayRank() == 1
-                    ? (Expression?) Expression.ArrayLength(source)
+                    ? (Expression?)Expression.ArrayLength(source)
                     : Expression.Property(source, "Length");
             }
             else
             {
                 var countProperty = GetCount(source.Type);
-                return countProperty != null 
-                    ? Expression.Property(source, countProperty) 
+                return countProperty != null
+                    ? Expression.Property(source, countProperty)
                     : null;
             }
         }
@@ -331,11 +412,11 @@ public static Expression ApplyNullPropagation(this Expression getter)
             var result = getter;
             while (current.NodeType == ExpressionType.MemberAccess)
             {
-                var memEx = (MemberExpression) current;
+                var memEx = (MemberExpression)current;
                 var expr = memEx.Expression;
                 if (expr == null)
                     break;
-                if (expr.NodeType == ExpressionType.Parameter) 
+                if (expr.NodeType == ExpressionType.Parameter)
                     return result;
 
                 if (expr.CanBeNull())