Merge pull request #104 from AutoMapper/ImprovingAnonymousTypeExpressionMapping

Handling property maps for anonymous ParameterExpression.

Author: BlaiseD

src/AutoMapper.Extensions.ExpressionMapping/TypeMapHelper.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Linq;
+
+namespace AutoMapper.Extensions.ExpressionMapping
+{
+    internal static class TypeMapHelper
+    {
+        public static IMemberMap GetMemberMapByDestinationProperty(this TypeMap typeMap, string destinationPropertyName)
+        {
+            var propertyMap = typeMap.PropertyMaps.SingleOrDefault(item => item.DestinationName == destinationPropertyName);
+            if (propertyMap != null)
+                return propertyMap;
+
+            var memberMap = typeMap.MemberMaps.OfType<ConstructorParameterMap>().SingleOrDefault(mm => mm.Parameter.Name == destinationPropertyName);
+            if (memberMap != null)
+                return memberMap;
+
+            throw PropertyConfigurationException(typeMap, destinationPropertyName);
+        }
+
+        public static TypeMap CheckIfTypeMapExists(this IConfigurationProvider config, Type sourceType, Type destinationType)
+        {
+            var typeMap = config.ResolveTypeMap(sourceType, destinationType);
+            if (typeMap == null)
+            {
+                throw MissingMapException(sourceType, destinationType);
+            }
+            return typeMap;
+        }
+
+        public static string GetDestinationName(this IMemberMap memberMap)
+        {
+            if (memberMap is PropertyMap propertyMap)
+                return propertyMap.DestinationMember.Name;
+
+            if (memberMap is ConstructorParameterMap constructorMap)
+                return constructorMap.Parameter.Name;
+            
+            throw new ArgumentException(nameof(memberMap));
+        }
+
+        private static Exception PropertyConfigurationException(TypeMap typeMap, params string[] unmappedPropertyNames)
+            => new AutoMapperConfigurationException(new[] { new AutoMapperConfigurationException.TypeMapConfigErrors(typeMap, unmappedPropertyNames, true) });
+
+        private static Exception MissingMapException(TypePair types)
+            => MissingMapException(types.SourceType, types.DestinationType);
+
+        private static Exception MissingMapException(Type sourceType, Type destinationType)
+            => new InvalidOperationException($"Missing map from {sourceType} to {destinationType}. Create using CreateMap<{sourceType.Name}, {destinationType.Name}>.");
+    }
+}

src/AutoMapper.Extensions.ExpressionMapping/XpressionMapperVisitor.cs

@@ -30,6 +30,9 @@ public XpressionMapperVisitor(IMapper mapper, IConfigurationProvider configurati
 
         protected IMapper Mapper { get; }
 
+        private IConfigurationProvider anonymousTypesConfigurationProvider;
+        private Configuration.MapperConfigurationExpression anonymousTypesBaseMappings = new Configuration.MapperConfigurationExpression();
+
         protected override Expression VisitParameter(ParameterExpression node)
         {
             InfoDictionary.Add(node, TypeMappings);
@@ -172,7 +175,7 @@ protected override Expression VisitNew(NewExpression node)
                 for (int i = 0; i < parameters.Length; i++)
                     bindingExpressions.Add(parameters[i].Name, this.Visit(node.Arguments[i]));
 
-                return GetMemberInitExpression(bindingExpressions, node.Type);
+                return GetAnonymousTypeMemberInitExpression(bindingExpressions, node.Type);
             }
 
             return base.VisitNew(node);
@@ -196,7 +199,7 @@ protected override Expression VisitMemberInit(MemberInitExpression node)
         {
             if (this.TypeMappings.TryGetValue(node.Type, out Type newType))
             {
-                var typeMap = ConfigurationProvider.CheckIfMapExists(sourceType: newType, destinationType: node.Type);
+                var typeMap = ConfigurationProvider.CheckIfTypeMapExists(sourceType: newType, destinationType: node.Type);
                 //The destination becomes the source because to map a source expression to a destination expression,
                 //we need the expressions used to create the source from the destination
 
@@ -221,7 +224,7 @@ protected override Expression VisitMemberInit(MemberInitExpression node)
             }
             else if (IsAnonymousType(node.Type))
             {
-                return GetMemberInitExpression
+                return GetAnonymousTypeMemberInitExpression
                 (
                     node.Bindings
                         .OfType<MemberAssignment>()
@@ -237,11 +240,36 @@ protected override Expression VisitMemberInit(MemberInitExpression node)
             return base.VisitMemberInit(node);
         }
 
-        private MemberInitExpression GetMemberInitExpression(Dictionary<string, Expression> bindingExpressions, Type oldType)
+        private void ConfigureAnonymousTypeMaps(Type oldType, Type newAnonymousType)
+        {
+            anonymousTypesBaseMappings.CreateMap(newAnonymousType, oldType);
+            Dictionary<Type, Type> memberTypeMaps = new Dictionary<Type, Type>();
+            newAnonymousType.GetMembers()
+                .OfType<PropertyInfo>()
+                .ToList()
+                .ForEach(member =>
+                {
+                    Type sourceType = member.GetMemberType();
+                    Type destMember = oldType.GetMember(member.Name)[0].GetMemberType();
+                    if (sourceType == destMember)
+                        return;
+
+                    if (!memberTypeMaps.ContainsKey(sourceType))
+                    {
+                        memberTypeMaps.Add(sourceType, destMember);
+                        anonymousTypesBaseMappings.CreateMap(sourceType, destMember);
+                    }
+                });
+
+            anonymousTypesConfigurationProvider = new MapperConfiguration(anonymousTypesBaseMappings);
+        }
+
+        private MemberInitExpression GetAnonymousTypeMemberInitExpression(Dictionary<string, Expression> bindingExpressions, Type oldType)
         {
             Type newAnonymousType = AnonymousTypeFactory.CreateAnonymousType(bindingExpressions.ToDictionary(a => a.Key, a => a.Value.Type));
             TypeMappings.AddTypeMapping(ConfigurationProvider, oldType, newAnonymousType);
 
+            ConfigureAnonymousTypeMaps(oldType, newAnonymousType);
             return Expression.MemberInit
             (
                 Expression.New(newAnonymousType),
@@ -593,7 +621,7 @@ protected void FindDestinationFullName(Type typeSource, Type typeDestination, st
             bool BothTypesAreAnonymous()
                 => IsAnonymousType(typeSource) && IsAnonymousType(typeDestination);
 
-            if (typeSource == typeDestination || BothTypesAreAnonymous())
+            if (typeSource == typeDestination)
             {
                 var sourceFullNameArray = sourceFullName.Split(new[] { period[0] }, StringSplitOptions.RemoveEmptyEntries);
                 sourceFullNameArray.Aggregate(propertyMapInfoList, (list, next) =>
@@ -644,7 +672,10 @@ bool BothTypesAreAnonymous()
                 }
             }
 
-            var typeMap = ConfigurationProvider.CheckIfMapExists(sourceType: typeDestination, destinationType: typeSource);//The destination becomes the source because to map a source expression to a destination expression,
+            var typeMap = BothTypesAreAnonymous()
+                ? anonymousTypesConfigurationProvider.CheckIfTypeMapExists(sourceType: typeDestination, destinationType: typeSource)
+                : ConfigurationProvider.CheckIfTypeMapExists(sourceType: typeDestination, destinationType: typeSource);
+            //The destination becomes the source because to map a source expression to a destination expression,
             //we need the expressions used to create the source from the destination 
 
             PathMap pathMap = typeMap.FindPathMapByDestinationPath(destinationFullPath: sourceFullName);
@@ -657,8 +688,8 @@ bool BothTypesAreAnonymous()
 
             if (sourceFullName.IndexOf(period, StringComparison.OrdinalIgnoreCase) < 0)
             {
-                var propertyMap = typeMap.GetPropertyMapByDestinationProperty(sourceFullName);
-                var sourceMemberInfo = typeSource.GetFieldOrProperty(propertyMap.DestinationMember.Name);
+                var propertyMap = typeMap.GetMemberMapByDestinationProperty(sourceFullName);
+                var sourceMemberInfo = typeSource.GetFieldOrProperty(propertyMap.GetDestinationName());
                 if (propertyMap.ValueResolverConfig != null)
                 {
                     throw new InvalidOperationException(Resource.customResolversNotSupported);
@@ -678,7 +709,7 @@ void CompareSourceAndDestLiterals(Type mappedPropertyType, string mappedProperty
                 {
                     //switch from IsValueType to IsLiteralType because we do not want to throw an exception for all structs
                     if ((mappedPropertyType.IsLiteralType() || sourceMemberType.IsLiteralType()) && sourceMemberType != mappedPropertyType)
-                        throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Resource.expressionMapValueTypeMustMatchFormat, mappedPropertyType.Name, mappedPropertyDescription, sourceMemberType.Name, propertyMap.DestinationMember.Name));
+                        throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Resource.expressionMapValueTypeMustMatchFormat, mappedPropertyType.Name, mappedPropertyDescription, sourceMemberType.Name, propertyMap.GetDestinationName()));
                 }
 
                 if (propertyMap.ProjectToCustomSource != null)
@@ -689,9 +720,9 @@ void CompareSourceAndDestLiterals(Type mappedPropertyType, string mappedProperty
             else
             {
                 var propertyName = sourceFullName.Substring(0, sourceFullName.IndexOf(period, StringComparison.OrdinalIgnoreCase));
-                var propertyMap = typeMap.GetPropertyMapByDestinationProperty(propertyName);
+                var propertyMap = typeMap.GetMemberMapByDestinationProperty(propertyName);
 
-                var sourceMemberInfo = typeSource.GetFieldOrProperty(propertyMap.DestinationMember.Name);
+                var sourceMemberInfo = typeSource.GetFieldOrProperty(propertyMap.GetDestinationName());
                 if (propertyMap.CustomMapExpression == null && !propertyMap.SourceMembers.Any())//If sourceFullName has a period then the SourceMember cannot be null.  The SourceMember is required to find the ProertyMap of its child object.
                     throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Resource.srcMemberCannotBeNullFormat, typeSource.Name, typeDestination.Name, propertyName));
 

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

@@ -655,6 +655,26 @@ public void Map_to_anonymous_type_when_init_member_is_not_a_literal()
             Assert.True(users[0].Account.Balance == 150000);
         }
 
+        [Fact]
+        public void Map_to_anonymous_type_when_init_member_is_not_a_literal_and_parameter_is_anonymous_type()
+        {
+            //Arrange
+            Expression<Func<IQueryable<UserModel>, IEnumerable<object>>> expression = q => q.OrderBy(s => s.Id).Select(u => new { UserId = u.Id, Account = u.AccountModel }).Where(a => a.Account.Bal != -1);
+
+            //Act
+            Expression<Func<IQueryable<User>, IEnumerable<object>>> expMapped = (Expression<Func<IQueryable<User>, IEnumerable<object>>>)mapper.MapExpression
+            (
+                expression,
+                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].UserId == 11);
+            Assert.True(users[0].Account.Balance == 150000);
+        }
+
         [Fact]
         public void Map_to_anonymous_type_when_init_member_is_not_a_literal_with_navigation_property()
         {