Merge pull request #57 from BlaiseD/master

Adding mapping for member init expressions.

Author: BlaiseD

Directory.Build.props

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

src/AutoMapper.Extensions.ExpressionMapping/XpressionMapperVisitor.cs

@@ -129,6 +129,40 @@ protected override Expression VisitLambda<T>(Expression<T> node)
             return mapped;
         }
 
+        protected override Expression VisitMemberInit(MemberInitExpression node)
+        {
+            if (this.TypeMappings.TryGetValue(node.Type, out Type newType))
+            {
+                var typeMap = ConfigurationProvider.CheckIfMapExists(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
+
+                IEnumerable<MemberBinding> bindings = node.Bindings.Select
+                (
+                    binding =>
+                    {
+                        Expression bindingExpression = ((MemberAssignment)binding).Expression;
+                        return DoBind
+                        (
+                            typeMap.GetPropertyMapByDestinationProperty(binding.Member.Name),
+                            bindingExpression,
+                            this.Visit(bindingExpression)
+                        );
+                    }
+                );
+
+                return Expression.MemberInit(Expression.New(newType), bindings);
+            }
+
+            return base.VisitMemberInit(node);
+        }
+
+        private MemberBinding DoBind(PropertyMap propertyMap, Expression initial, Expression mapped)
+        {
+            this.TypeMappings.AddTypeMapping(ConfigurationProvider, initial.Type, mapped.Type);
+            return Expression.Bind(propertyMap.SourceMember, mapped);
+        }
+
         protected override Expression VisitBinary(BinaryExpression node)
         {
             return DoVisitBinary(this.Visit(node.Left), this.Visit(node.Right), this.Visit(node.Conversion));

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

@@ -415,6 +415,20 @@ public void Map__select_method_projecting_to_anonymous_type()
             Assert.True(bars.Count == 1);
         }
 
+        [Fact]
+        public void Map__select_method_projecting_to_model_type()
+        {
+            //Arrange
+            Expression<Func<UserModel, IEnumerable<ThingModel>>> selection = s => s.AccountModel.ThingModels.Select(x => new ThingModel { Car = x.Car }).Where(b => b.Color.EndsWith("e"));
+
+            //Act
+            Expression<Func<User, IEnumerable<Thing>>> selectionMapped = mapper.MapExpression<Expression<Func<User, IEnumerable<Thing>>>>(selection);
+            List<Thing> things = Users.SelectMany(selectionMapped).ToList();
+
+            //Assert
+            Assert.True(things.Count == 2);
+        }
+
         [Fact]
         public void Map__select_method_where_parent_type_is_grandchild_type()
         {