Allow properties or fields to contain periods

Author: JMolenkamp

src/Mapster/Utils/ExpressionEx.cs

@@ -19,8 +19,64 @@ 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++)
+            {
+                Exception initialException;
+
+                try
+                {
+                    string prop = props[i];
+                    current = PropertyOrField(current, prop);
+                    continue;
+                }
+                catch (Exception ex) when (props.Length - i > 1) // Only catch when parts remain
+                {
+                    // Store the exception to rethrow in the end if the alternative approach fails
+                    initialException = ex;
+                }
+
+                // 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. 
+                try
+                {
+                    (current, int combinationLength) = PropertyOrFieldPathWithPeriods(current, props[i..]);
+                    i += combinationLength - 1;
+                }
+                catch
+                {
+                    // Rethrow the original exception for the first part
+                    ExceptionDispatchInfo.Capture(initialException).Throw();
+                }
+            }
+
+            return current;
+        }
+
+        private static (Expression Expression, int CombinationLength) PropertyOrFieldPathWithPeriods(Expression expr, string[] path)
+        {
+            if (path.Length < 2)
+            {
+                throw new ArgumentException($"Value should contain at least 2 elements, got {path.Length}.", nameof(path));
+            }
+
+            for (int count = 2; count <= path.Length; count++)
+            {
+                try
+                {
+                    string prop = string.Join('.', path[..count]);
+                    return (PropertyOrField(expr, prop), count);
+                }
+                catch when (count < path.Length)
+                {
+                    // Only throw for the last element, no property or field was found
+                }
+            }
+
+            // This is not reachable, right?
+            throw new NotSupportedException("This should not be reachable.");
         }
 
         private static Expression PropertyOrField(Expression expr, string prop)