Fix breaking changes from AutoMapper v8.1.0

Directory.Build.props

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

src/AutoMapper.Extensions.ExpressionMapping/AutoMapper.Extensions.ExpressionMapping.csproj

@@ -17,7 +17,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="AutoMapper" Version="8.0.0" />
+    <PackageReference Include="AutoMapper" Version="8.1.0" />
   </ItemGroup>
 
 </Project>

src/AutoMapper.Extensions.ExpressionMapping/ExpressionMapper.cs

@@ -269,7 +269,15 @@ private PropertyMap PropertyMap(MemberExpression node)
                         ? null
                         : (!node.Member.DeclaringType.IsAssignableFrom(_typeMap.DestinationType)
                             ? null
-                            : _typeMap.GetExistingPropertyMapFor(node.Member)));
+                            : GetExistingPropertyMapFor(node.Member, _typeMap)));
+
+            private PropertyMap GetExistingPropertyMapFor(MemberInfo destinationProperty, TypeMap typeMap)
+            {
+                if (!destinationProperty.DeclaringType.IsAssignableFrom(typeMap.DestinationType))
+                    return null;
+
+                return typeMap.PropertyMaps.FirstOrDefault(pm => pm.DestinationName == destinationProperty.Name);
+            }
 
             private void SetSorceSubTypes(PropertyMap propertyMap)
             {

src/AutoMapper.Extensions.ExpressionMapping/Impl/QueryDataSourceInjection.cs

@@ -72,20 +72,20 @@ public QueryDataSourceInjection(IQueryable<TSource> dataSource, IMapper mapper)
         public ISourceInjectedQueryable<TDestination> For<TDestination>(object parameters, params Expression<Func<TDestination, object>>[] membersToExpand)
         {
             _parameters = GetParameters(parameters);
-            _membersToExpand = ProjectionExpression.GetMemberPaths(membersToExpand);
+            _membersToExpand = ReflectionExtensions.GetMemberPaths(membersToExpand);
             return CreateQueryable<TDestination>();
         }
 
         public ISourceInjectedQueryable<TDestination> For<TDestination>(params Expression<Func<TDestination, object>>[] membersToExpand)
         {
-            _membersToExpand = ProjectionExpression.GetMemberPaths(membersToExpand);
+            _membersToExpand = ReflectionExtensions.GetMemberPaths(membersToExpand);
             return CreateQueryable<TDestination>();
         }
 
         public ISourceInjectedQueryable<TDestination> For<TDestination>(IObjectDictionary parameters, params string[] membersToExpand)
         {
             _parameters = parameters;
-            _membersToExpand = ProjectionExpression.GetMemberPaths(typeof(TDestination), membersToExpand);
+            _membersToExpand = ReflectionExtensions.GetMemberPaths(typeof(TDestination), membersToExpand);
             return CreateQueryable<TDestination>();
         }
 

src/AutoMapper.Extensions.ExpressionMapping/Impl/SourceInjectedQueryProvider.cs

@@ -94,7 +94,12 @@ public TResult Execute<TResult>(Expression expression)
                     var sourceResult = _dataSource.Provider.CreateQuery(sourceExpression);
                     Inspector.SourceResult(sourceExpression, sourceResult);
 
-                    destResult = new ProjectionExpression((IQueryable<TSource>)sourceResult, _mapper.ConfigurationProvider.ExpressionBuilder).To<TDestination>(_parameters, _membersToExpand);
+                    var membersToExpand = _membersToExpand.SelectMany(m => m).Distinct().ToArray();
+
+                    var parameters = _parameters ?? new Dictionary<string, object>();
+                    var mapExpressions = _mapper.ConfigurationProvider.ExpressionBuilder.GetMapExpression(sourceResult.ElementType, typeof(TDestination), parameters, membersToExpand);
+
+                    destResult = (IQueryable<TDestination>)mapExpressions.Aggregate(sourceResult, Select);
                 }
                 // case #2: query is arbitrary ("manual") projection
                 // exaple: users.UseAsDataSource().For<UserDto>().Select(user => user.Age).ToList()
@@ -228,6 +233,14 @@ private static Expression Select(Expression source, LambdaExpression lambda)
                 );
         }
 
+        private static IQueryable Select(IQueryable source, LambdaExpression lambda) => source.Provider.CreateQuery(
+                Call(
+                    null,
+                    QueryableSelectMethod.MakeGenericMethod(source.ElementType, lambda.ReturnType),
+                    new[] { source.Expression, Expression.Quote(lambda) }
+                    )
+                );
+
         private object InvokeSourceQuery(Type sourceResultType, Expression sourceExpression)
         {
             var result = IsProjection<TSource>(sourceResultType)

src/AutoMapper.Extensions.ExpressionMapping/ReflectionExtensions.cs

@@ -1,11 +1,14 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
 using AutoMapper.Internal;
 
 namespace AutoMapper
 {
+    using MemberPaths = IEnumerable<IEnumerable<MemberInfo>>;
+
     internal static class ReflectionExtensions
     {
         public static object GetDefaultValue(this ParameterInfo parameter)
@@ -29,6 +32,12 @@ public static object GetMemberValue(this MemberInfo propertyOrField, object targ
         public static IEnumerable<MemberInfo> GetMemberPath(Type type, string fullMemberName)
             => ReflectionHelper.GetMemberPath(type, fullMemberName);
 
+        public static MemberPaths GetMemberPaths(Type type, string[] membersToExpand) =>
+            membersToExpand.Select(m => ReflectionHelper.GetMemberPath(type, m));
+
+        public static MemberPaths GetMemberPaths<TResult>(Expression<Func<TResult, object>>[] membersToExpand) =>
+            membersToExpand.Select(expr => MemberVisitor.GetMemberPath(expr));
+
         public static MemberInfo GetFieldOrProperty(this LambdaExpression expression)
             => ReflectionHelper.GetFieldOrProperty(expression);