Merge pull request #44 from BlaiseD/master

No Generics MapExpression extension and handling ExpressionType.TypeAs

Author: BlaiseD

Directory.Build.props

@@ -2,7 +2,7 @@
   <PropertyGroup>
     <Authors>Jimmy Bogard</Authors>
     <LangVersion>latest</LangVersion>
-    <VersionPrefix>3.0.2-preview02</VersionPrefix>
+    <VersionPrefix>3.0.2</VersionPrefix>
     <WarningsAsErrors>true</WarningsAsErrors>
     <NoWarn>$(NoWarn);1701;1702;1591</NoWarn>
   </PropertyGroup>

src/AutoMapper.Extensions.ExpressionMapping/Extensions/VisitorExtensions.cs

@@ -115,6 +115,8 @@ public static ParameterExpression GetParameterExpression(this Expression express
                 case ExpressionType.Convert:
                     var ue = expression as UnaryExpression;
                     return GetParameterExpression(ue?.Operand);
+                case ExpressionType.TypeAs:
+                    return ((UnaryExpression)expression).Operand.GetParameterExpression();
                 case ExpressionType.MemberAccess:
                     return GetParameterExpression(((MemberExpression)expression).Expression);
                 case ExpressionType.Call:
@@ -138,16 +140,10 @@ public static ParameterExpression GetParameterExpression(this Expression express
         /// </summary>
         /// <param name="expression"></param>
         /// <returns></returns>
-        public static Expression GetBaseOfMemberExpression(this MemberExpression expression)
-        {
-            switch (expression.Expression.NodeType)
-            {
-                case ExpressionType.MemberAccess:
-                    return GetBaseOfMemberExpression((MemberExpression)expression.Expression);
-                default:
-                    return expression.Expression;
-            }
-        }
+        public static Expression GetBaseOfMemberExpression(this MemberExpression expression) 
+            => expression.Expression.NodeType == ExpressionType.MemberAccess
+                ? GetBaseOfMemberExpression((MemberExpression)expression.Expression)
+                : expression.Expression;
 
         /// <summary>
         /// Adds member expressions to an existing expression.

src/AutoMapper.Extensions.ExpressionMapping/MapperExtensions.cs

@@ -11,6 +11,35 @@ namespace AutoMapper.Extensions.ExpressionMapping
 {
     public static class MapperExtensions
     {
+        /// <summary>
+        /// Maps an expression from typeof(Expression&lt;TSource&gt;) to typeof(Expression&lt;TTarget&gt;)
+        /// </summary>
+        /// <param name="mapper"></param>
+        /// <param name="expression"></param>
+        /// <param name="sourceExpressionType"></param>
+        /// <param name="destExpressionType"></param>
+        /// <returns></returns>
+        public static LambdaExpression MapExpression(this IMapper mapper, LambdaExpression expression, Type sourceExpressionType, Type destExpressionType)
+        {
+            if (expression == null)
+                return default;
+
+            return (LambdaExpression)"_MapExpression".GetMapExpressionMethod().MakeGenericMethod
+            (
+                sourceExpressionType,
+                destExpressionType
+            ).Invoke(null, new object[] { mapper, expression });
+        }
+
+        private static TDestDelegate _MapExpression<TSourceDelegate, TDestDelegate>(this IMapper mapper, TSourceDelegate expression)
+            where TSourceDelegate : LambdaExpression
+            where TDestDelegate : LambdaExpression
+            => mapper.MapExpression<TSourceDelegate, TDestDelegate>(expression);
+
+
+        private static MethodInfo GetMapExpressionMethod(this string methodName)
+            => typeof(MapperExtensions).GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Static);
+
         /// <summary>
         /// Maps an expression given a dictionary of types where the source type is the key and the destination type is the value.
         /// </summary>
@@ -36,7 +65,6 @@ private static TDestDelegate MapExpression<TDestDelegate>(this IMapper mapper, L
         {
             return MapExpression<TDestDelegate>
             (
-                mapper,
                 mapper.ConfigurationProvider,
                 expression,
                 expression.GetType().GetGenericArguments()[0],
@@ -45,8 +73,7 @@ private static TDestDelegate MapExpression<TDestDelegate>(this IMapper mapper, L
             );
         }
 
-        private static TDestDelegate MapExpression<TDestDelegate>(IMapper mapper,
-            IConfigurationProvider configurationProvider,
+        private static TDestDelegate MapExpression<TDestDelegate>(IConfigurationProvider configurationProvider,
             LambdaExpression expression,
             Type typeSourceFunc,
             Type typeDestFunc,

tests/AutoMapper.Extensions.ExpressionMapping.UnitTests/XpressionMapperTests.cs

@@ -119,7 +119,7 @@ public void Map_object_type_change()
             //Assert
             Assert.True(users.Count == 1);
         }
-        
+
         [Fact]
         public void Map_works_with_members_from_interfaces()
         {
@@ -482,6 +482,25 @@ public void Map_orderBy_thenBy_To_Dictionary_Select_expression()
             Assert.True(users[0].Id == 11);
         }
 
+        [Fact]
+        public void Map_orderBy_thenBy_To_Dictionary_Select_expression_without_generic_types()
+        {
+            //Arrange
+            Expression<Func<IQueryable<UserModel>, IEnumerable<object>>> grouped = q => q.OrderBy(s => s.Id).ThenBy(s => s.FullName).ToDictionary(kvp => kvp.Id).Select(grp => new { Id = grp.Key, Name = grp.Value.FullName });
+
+            //Act
+            Expression<Func<IQueryable<User>, IEnumerable<object>>> expMapped = (Expression<Func<IQueryable<User>, IEnumerable<object>>>)mapper.MapExpression
+            (
+                grouped, 
+                typeof(Expression<Func<IQueryable<UserModel>, IEnumerable<object>>>), 
+                typeof(Expression<Func<IQueryable<User>, IEnumerable<object>>>)
+            );
+
+            List<dynamic> users = expMapped.Compile().Invoke(Users).ToList();
+
+            Assert.True(users[0].Id == 11);
+        }
+
         [Fact]
         public void Map_dynamic_return_type()
         {
@@ -534,6 +553,23 @@ public void Map_parentDto_to_parent()
             Assert.NotNull(expMapped);
         }
 
+        [Fact]
+        public void Can_map_expression_where_parent_of_member_expression_is_typeAsExpression()
+        {
+            //Arrange
+            Parent[] parents = new Parent[]
+            {
+                new Parent {  DateTimeObject = new DateTime?(new DateTime(2019, 9, 7))}
+            };
+            Expression<Func<ParentDTO, bool>> exp = p => (p.DateTimeObject as DateTime?).Value.Year.ToString() == "2019";
+
+            //Act
+            Expression<Func<Parent, bool>> expMapped = mapper.Map<Expression<Func<Parent, bool>>>(exp);
+
+            //Assert
+            Assert.Equal(1, parents.AsQueryable<Parent>().Count(expMapped));
+        }
+
         [Fact]
         public void Map_parentDto_to_parent_with_index_argument()
         {
@@ -1011,6 +1047,7 @@ public class ParentDTO
         public ICollection<ChildDTO> Children { get; set; }
         public ChildDTO Child { get; set; }
         public DateTime DateTime { get; set; }
+        public object DateTimeObject { get; set; }
     }
 
     public class ChildDTO
@@ -1042,6 +1079,7 @@ public Child Child
             }
         }
         public DateTime DateTime { get; set; }
+        public object DateTimeObject { get; set; }
     }
 
     public class Child
@@ -1259,7 +1297,6 @@ public OrganizationProfile()
 
             CreateMap<EmployeeModel, EmployeeEntity>().ReverseMap();
             CreateMap<EventModel, EventEntity>().ReverseMap();
-            //CreateMap<EventEntity, EmployeeModel>();
         }
     }