Merge pull request #11 from TylerCarlson1/5.0Compatible

TylerCarlson1 · web-flow · commit 074d4fdb162e · 2016-06-29T00:06:02.000-05:00
Moving to IObjectMapExpression
diff --git a/global.json b/global.json
@@ -1,5 +1,6 @@
 {
     "sdk": {
       "version": "1.0.0-preview1-002702"
-    }
+    },
+    "projects": []
 }
diff --git a/src/AutoMapper.Collection-Signed/project.json b/src/AutoMapper.Collection-Signed/project.json
@@ -18,21 +18,27 @@
   },
 
   "dependencies": {
-    "AutoMapper": "4.2.1"
+    "AutoMapper": "5.0.0"
   },
 
   "frameworks": {
     "net45": {
+      "dependencies": {
+      }
     },
     "netstandard1.1": {
       "dependencies": {
-        "NETStandard.Library": "1.5.0-rc2-24027",
-        "System.Linq.Expressions": "4.0.11-rc2-24027"
+        "System.Threading": "4.0.11"
       },
       "imports": [
         "portable-net45+win8+dnxcore50",
         "portable-net45+win8"
       ]
+    },
+    "netstandard1.3": {
+      "dependencies": {
+        "System.Threading": "4.0.11"
+      }
+      }
     }
-  }
-}
+  }
diff --git a/src/AutoMapper.Collection.EntityFramework/Extensions.cs b/src/AutoMapper.Collection.EntityFramework/Extensions.cs
@@ -15,11 +15,10 @@ public static class Extensions
         /// <typeparam name="TSource">Source table type to be updated</typeparam>
         /// <param name="source">DbSet to be updated</param>
         /// <returns>Persistance object to Update or Remove data</returns>
-        [Obsolete("Use version that passes instance of IMapper")]
         public static IPersistance Persist<TSource>(this DbSet<TSource> source)
             where TSource : class
         {
-            return new Persistance<TSource>(source, null);
+            return new Persistance<TSource>(source, Mapper.Instance);
         }
 
         /// <summary>
diff --git a/src/AutoMapper.Collection.EntityFramework/GenerateEntityFrameworkPrimaryKeyEquivilentExpressions.cs b/src/AutoMapper.Collection.EntityFramework/GenerateEntityFrameworkPrimaryKeyEquivilentExpressions.cs
@@ -16,17 +16,16 @@ public class GenerateEntityFrameworkPrimaryKeyEquivilentExpressions<TDatabaseCon
         /// </summary>
         /// <param name="mapper">IMapper used to find TypeMap between classes</param>
         public GenerateEntityFrameworkPrimaryKeyEquivilentExpressions(IMapper mapper)
-            : base(new GenerateEntityFrameworkPrimaryKeyPropertyMaps<TDatabaseContext>(mapper))
+            : base(new GenerateEntityFrameworkPrimaryKeyPropertyMaps<TDatabaseContext>(mapper.ConfigurationProvider))
         {
         }
 
         /// <summary>
         /// Generate EquivilencyExpressions based on EnityFramework's primary key
         /// Uses static API's Mapper for finding TypeMap between classes
         /// </summary>
-        [Obsolete("Use version that passes instance of IMapper")]
         public GenerateEntityFrameworkPrimaryKeyEquivilentExpressions()
-           : base(new GenerateEntityFrameworkPrimaryKeyPropertyMaps<TDatabaseContext>(null))
+            : base(new GenerateEntityFrameworkPrimaryKeyPropertyMaps<TDatabaseContext>(Mapper.Configuration))
         {
         }
     }
diff --git a/src/AutoMapper.Collection.EntityFramework/GenerateEntityFrameworkPrimaryKeyPropertyMatches.cs b/src/AutoMapper.Collection.EntityFramework/GenerateEntityFrameworkPrimaryKeyPropertyMatches.cs
@@ -12,21 +12,19 @@ namespace AutoMapper.EntityFramework
     public class GenerateEntityFrameworkPrimaryKeyPropertyMaps<TDatabaseContext> : IGeneratePropertyMaps
         where TDatabaseContext : IObjectContextAdapter, new()
     {
-        private readonly IMapper _mapper;
+        private readonly IConfigurationProvider _configurationProvider;
 
         private readonly TDatabaseContext _context = new TDatabaseContext();
         private readonly MethodInfo _createObjectSetMethodInfo = typeof(ObjectContext).GetMethod("CreateObjectSet", Type.EmptyTypes);
 
-        public GenerateEntityFrameworkPrimaryKeyPropertyMaps(IMapper mapper)
+        public GenerateEntityFrameworkPrimaryKeyPropertyMaps(IConfigurationProvider configurationProvider)
         {
-            _mapper = mapper;
+            _configurationProvider = configurationProvider;
         }
 
         public IEnumerable<PropertyMap> GeneratePropertyMaps(Type srcType, Type destType)
         {
-            var typeMap = _mapper == null
-                ? (Mapper.Configuration as IConfigurationProvider).ResolveTypeMap(srcType, destType)
-                : _mapper.ConfigurationProvider.ResolveTypeMap(srcType, destType);
+            var typeMap = _configurationProvider.ResolveTypeMap(srcType, destType);
             var propertyMaps = typeMap.GetPropertyMaps();
             var createObjectSetMethod = _createObjectSetMethodInfo.MakeGenericMethod(destType);
             dynamic objectSet = createObjectSetMethod.Invoke(_context.ObjectContext, null);
diff --git a/src/AutoMapper.Collection.LinqToSQL/GetLinqToSQLPrimaryKeyExpression.cs b/src/AutoMapper.Collection.LinqToSQL/GetLinqToSQLPrimaryKeyExpression.cs
@@ -10,17 +10,16 @@ public class GetLinqToSQLPrimaryKeyExpression : GenerateEquivilentExpressionsBas
         /// </summary>
         /// <param name="mapper">IMapper used to find TypeMap between classes</param>
         public GetLinqToSQLPrimaryKeyExpression(IMapper mapper)
-            : base(new GetLinqToSQLPrimaryKeyProperties(mapper))
+            : base(new GetLinqToSQLPrimaryKeyProperties(mapper.ConfigurationProvider))
         {
         }
 
         /// <summary>
         /// Generate EquivilencyExpressions based on LinqToSQL's primary key
         /// Uses static API's Mapper for finding TypeMap between classes
         /// </summary>
-        [Obsolete("Use version that passes instance of IMapper")]
         public GetLinqToSQLPrimaryKeyExpression()
-           : base(new GetLinqToSQLPrimaryKeyProperties(null))
+           : base(new GetLinqToSQLPrimaryKeyProperties(Mapper.Configuration))
         {
         }
     }
diff --git a/src/AutoMapper.Collection.LinqToSQL/GetLinqToSQLPrimaryKeyProperties.cs b/src/AutoMapper.Collection.LinqToSQL/GetLinqToSQLPrimaryKeyProperties.cs
@@ -9,18 +9,18 @@ namespace AutoMapper.Collection.LinqToSQL
 {
     public class GetLinqToSQLPrimaryKeyProperties : IGeneratePropertyMaps
     {
-        private readonly IMapper _mapper;
-
-        public GetLinqToSQLPrimaryKeyProperties(IMapper mapper)
+        private readonly IConfigurationProvider _configurationProvider;
+        
+        public GetLinqToSQLPrimaryKeyProperties(IConfigurationProvider configurationProvider)
         {
-            _mapper = mapper;
+            if (configurationProvider == null)
+                throw new ArgumentNullException(nameof(configurationProvider));
+            _configurationProvider = configurationProvider;
         }
 
         public IEnumerable<PropertyMap> GeneratePropertyMaps(Type srcType, Type destType)
         {
-            var typeMap = _mapper == null
-                ? (Mapper.Configuration as IConfigurationProvider).ResolveTypeMap(srcType, destType)
-                : _mapper.ConfigurationProvider.ResolveTypeMap(srcType, destType);
+            var typeMap = _configurationProvider.ResolveTypeMap(srcType, destType);
             var propertyMaps = typeMap.GetPropertyMaps();
 
             var primaryKeyPropertyMatches = destType.GetProperties().Where(IsPrimaryKey).Select(m => propertyMaps.FirstOrDefault(p => p.DestinationProperty.Name == m.Name)).ToList();
diff --git a/src/AutoMapper.Collection.LinqToSQL/PersistanceExtensions.cs b/src/AutoMapper.Collection.LinqToSQL/PersistanceExtensions.cs
@@ -15,11 +15,10 @@ public static class PersistanceExtensions
         /// <typeparam name="TSource">Source table type to be updated</typeparam>
         /// <param name="source">Table to be updated</param>
         /// <returns>Persistance object to Update or Remove data</returns>
-        [Obsolete("Use version that passes instance of IMapper")]
         public static IPersistance Persist<TSource>(this Table<TSource> source)
             where TSource : class
         {
-            return new Persistance<TSource>(source, null);
+            return new Persistance<TSource>(source, Mapper.Instance);
         }
 
         /// <summary>
diff --git a/src/AutoMapper.Collection/Equivilency Expression/CustomExpressionVisitor.cs b/src/AutoMapper.Collection/Equivilency Expression/CustomExpressionVisitor.cs
@@ -3,6 +3,7 @@
 using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
+using AutoMapper.Execution;
 
 namespace AutoMapper.EquivilencyExpression
 {
@@ -29,11 +30,8 @@ protected override Expression VisitMember(MemberExpression node)
                 var matchPM = _propertyMaps.FirstOrDefault(pm => pm.DestinationProperty.MemberInfo == node.Member);
                 if (matchPM == null)
                     throw new Exception("No matching PropertyMap");
-                var sourceValueResolvers = matchPM.GetSourceValueResolvers();
-                if (!sourceValueResolvers.All(r => r is IMemberGetter))
-                    throw new Exception("Not all member getters");
-
-                var memberGetters = sourceValueResolvers.OfType<IMemberGetter>();
+                var memberGetters = matchPM.SourceMembers;
+                
                 var memberExpression = Expression.Property(Visit(node.Expression), memberGetters.First().MemberInfo as PropertyInfo);
 
                 foreach (var memberGetter in memberGetters.Skip(1))
diff --git a/src/AutoMapper.Collection/Equivilency Expression/EquivilentExpression.cs b/src/AutoMapper.Collection/Equivilency Expression/EquivilentExpression.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Linq.Expressions;
 using System.Reflection;
+using AutoMapper.Execution;
 
 namespace AutoMapper.EquivilencyExpression
 {
@@ -12,61 +13,33 @@ static EquivilentExpression()
         {
             BadValue = new EquivilentExpression();
         }
-
-        public bool IsEquivlent(object source, object destination)
-        {
-            throw new NotImplementedException();
-        }
     }
 
-    internal class EquivilentExpression<TSource,TDestination> : IEquivilentExpression , IToSingleSourceEquivalentExpression
+    internal class EquivilentExpression<TSource,TDestination> : IEquivilentExpression<TSource, TDestination>
         where TSource : class 
         where TDestination : class
     {
         private readonly Expression<Func<TSource, TDestination, bool>> _equivilentExpression;
+        private readonly Func<TSource, TDestination, bool> _equivilentFunc; 
 
         public EquivilentExpression(Expression<Func<TSource,TDestination,bool>> equivilentExpression)
         {
             _equivilentExpression = equivilentExpression;
+            _equivilentFunc = _equivilentExpression.Compile();
         }
 
-        public bool IsEquivlent(object source, object destination)
+        public bool IsEquivlent(TSource source, TDestination destination)
         {
-            if(!(source is TSource))
-                throw new EquivilentExpressionNotOfTypeException(source.GetType(), typeof(TSource));
-            if (!(destination is TDestination))
-                throw new EquivilentExpressionNotOfTypeException(destination.GetType(), typeof(TDestination));
-            return _equivilentExpression.Compile()(source as TSource, destination as TDestination);
+            return _equivilentFunc(source, destination);
         }
 
-        public Expression ToSingleSourceExpression(object source)
+        public Expression<Func<TDestination, bool>> ToSingleSourceExpression(TSource source)
         {
             if (source == null)
                 throw new Exception("Invalid somehow");
-            return GetSourceOnlyExpresison(source as TSource);
-        }
 
-        internal Expression GetSourceOnlyExpresison(TSource source)
-        {
             var expression = new ParametersToConstantVisitor<TSource>(source).Visit(_equivilentExpression) as LambdaExpression;
-            return Expression.Lambda(expression.Body, _equivilentExpression.Parameters[1]);
-        }
-
-        private class EquivilentExpressionNotOfTypeException : Exception
-        {
-            private readonly Type _objectType;
-            private readonly Type _expectedType;
-
-            public EquivilentExpressionNotOfTypeException(Type objectType, Type expectedType)
-            {
-                _objectType = objectType;
-                _expectedType = expectedType;
-            }
-
-            public override string Message
-            {
-                get { return string.Format("{0} does not equal or inherit from {1}", _objectType.Name, _expectedType.Name); }
-            }
+            return Expression.Lambda<Func<TDestination, bool>>(expression.Body, _equivilentExpression.Parameters[1]);
         }
     }
 
diff --git a/src/AutoMapper.Collection/Equivilency Expression/IEquivilentExpression.cs b/src/AutoMapper.Collection/Equivilency Expression/IEquivilentExpression.cs
@@ -1,14 +1,15 @@
+using System;
 using System.Linq.Expressions;
 
 namespace AutoMapper.EquivilencyExpression
 {
     public interface IEquivilentExpression
     {
-        bool IsEquivlent(object source, object destination);
+        
     }
-
-    public interface IToSingleSourceEquivalentExpression
+    public interface IEquivilentExpression<TSource, TDestination> : IEquivilentExpression
     {
-        Expression ToSingleSourceExpression(object destination);
+        bool IsEquivlent(TSource source, TDestination destination);
+        Expression<Func<TDestination, bool>> ToSingleSourceExpression(TSource destination);
     }
 }
diff --git a/src/AutoMapper.Collection/Mappers/EquivlentExpressionAddRemoveCollectionMapper.cs b/src/AutoMapper.Collection/Mappers/EquivlentExpressionAddRemoveCollectionMapper.cs
@@ -1,82 +1,63 @@
 ﻿using System;
-using System.Collections;
-using System.Collections.Concurrent;
+using System.Collections.Generic;
 using System.Linq;
-using AutoMapper.EquivilencyExpression;
-using AutoMapper.Internal;
+using System.Linq.Expressions;
 using System.Reflection;
+using AutoMapper.Configuration;
+using AutoMapper.EquivilencyExpression;
 
 namespace AutoMapper.Mappers
 {
     public class EquivlentExpressionAddRemoveCollectionMapper : IObjectMapper
     {
-        private readonly ConcurrentDictionary<Type, MethodCacheItem> _methodCache = new ConcurrentDictionary<Type, MethodCacheItem>();
-        private readonly CollectionMapper _collectionMapper = new CollectionMapper();
-
-        public object Map(ResolutionContext context)
+        private readonly CollectionMapper CollectionMapper = new CollectionMapper();
+        public static TDestination Map<TSource, TSourceItem, TDestination, TDestinationItem>(TSource source, TDestination destination, ResolutionContext context, Func<TDestination> ifNullFunc)
+            where TSource : IEnumerable<TSourceItem>
+            where TDestination : class, ICollection<TDestinationItem>
         {
-            if (context.IsSourceValueNull || context.DestinationValue == null)
-                return _collectionMapper.Map(context);
-
-            var sourceElementType = TypeHelper.GetElementType(context.SourceType);
-            var destinationElementType = TypeHelper.GetElementType(context.DestinationType);
-            var equivilencyExpression = GetEquivilentExpression(new TypePair(context.SourceType, context.DestinationType));
+            if (source == null || destination == null)
+                return ifNullFunc();
 
-            var destEnumerable = context.DestinationValue as IEnumerable;
-            var sourceEnumerable = context.SourceValue as IEnumerable;
+            var equivilencyExpression = GetEquivilentExpression(new TypePair(typeof(TSource), typeof(TDestination))) as IEquivilentExpression<TSourceItem,TDestinationItem>;
+            var compareSourceToDestination = source.ToDictionary(s => s, s => destination.FirstOrDefault(d => equivilencyExpression.IsEquivlent(s, d)));
 
-            var destItems = destEnumerable.Cast<object>().ToList();
-            var sourceItems = sourceEnumerable.Cast<object>().ToList();
-            var compareSourceToDestination = sourceItems.ToDictionary(s => s, s => destItems.FirstOrDefault(d => equivilencyExpression.IsEquivlent(s, d)));
-
-            var actualDestType = destEnumerable.GetType();
-            var methodItem = _methodCache.GetOrAdd(actualDestType, t =>
-            {
-                var addMethod = actualDestType.GetTypeInfo().GetDeclaredMethod("Add");
-                var removeMethod = actualDestType.GetTypeInfo().GetDeclaredMethod("Remove");
-                return new MethodCacheItem
-                {
-                    Add = (e, o) => addMethod.Invoke(e, new[] {o}),
-                    Remove = (e, o) => removeMethod.Invoke(e, new[] {o})
-                };
-            });
+            foreach (var removedItem in destination.Except(compareSourceToDestination.Values).ToList())
+                destination.Remove(removedItem);
 
             foreach (var keypair in compareSourceToDestination)
             {
                 if (keypair.Value == null)
-                {
-                    methodItem.Add(destEnumerable, context.Engine.Mapper.Map(keypair.Key, sourceElementType, destinationElementType));
-                }
+                    destination.Add(context.Mapper.Map<TDestinationItem>(keypair.Key));
                 else
-                {
-                    context.Engine.Mapper.Map(keypair.Key, keypair.Value, sourceElementType, destinationElementType);
-                }
-            }
-
-            foreach (var removedItem in destItems.Except(compareSourceToDestination.Values))
-            {
-                methodItem.Remove(destEnumerable, removedItem);
+                    context.Mapper.Map(keypair.Key, keypair.Value);
             }
 
-            return destEnumerable;
+            return destination;
         }
 
+        private static readonly MethodInfo MapMethodInfo = typeof(EquivlentExpressionAddRemoveCollectionMapper).GetRuntimeMethods().First(_ => _.IsStatic);
+        
+
         public bool IsMatch(TypePair typePair)
         {
             return typePair.SourceType.IsEnumerableType()
                    && typePair.DestinationType.IsCollectionType()
                    && GetEquivilentExpression(typePair) != null;
         }
 
-        private static IEquivilentExpression GetEquivilentExpression(TypePair typePair)
+        public Expression MapExpression(TypeMapRegistry typeMapRegistry, IConfigurationProvider configurationProvider,
+            PropertyMap propertyMap, Expression sourceExpression, Expression destExpression, Expression contextExpression)
         {
-            return EquivilentExpressions.GetEquivilentExpression(TypeHelper.GetElementType(typePair.SourceType), TypeHelper.GetElementType(typePair.DestinationType));
+            var collectionExpression = CollectionMapper.MapExpression(typeMapRegistry, configurationProvider, propertyMap, sourceExpression, destExpression, contextExpression);
+            var collectionFunc = Expression.Lambda(collectionExpression).Compile();
+            return Expression.Call(null,
+                MapMethodInfo.MakeGenericMethod(sourceExpression.Type, TypeHelper.GetElementType(sourceExpression.Type), destExpression.Type, TypeHelper.GetElementType(destExpression.Type)),
+                    sourceExpression, destExpression, contextExpression, Expression.Constant(collectionFunc));
         }
 
-        private class MethodCacheItem
+        private static IEquivilentExpression GetEquivilentExpression(TypePair typePair)
         {
-            public Action<IEnumerable, object> Add { get; set; }
-            public Action<IEnumerable, object> Remove { get; set; }
+            return EquivilentExpressions.GetEquivilentExpression(TypeHelper.GetElementType(typePair.SourceType), TypeHelper.GetElementType(typePair.DestinationType));
         }
     }
 }
diff --git a/src/AutoMapper.Collection/Mappers/ObjectToEquivalencyExpressionByEquivalencyExistingMapper.cs b/src/AutoMapper.Collection/Mappers/ObjectToEquivalencyExpressionByEquivalencyExistingMapper.cs
diff --git a/src/AutoMapper.Collection/ReflectionHelper.cs b/src/AutoMapper.Collection/ReflectionHelper.cs
diff --git a/src/AutoMapper.Collection/project.json b/src/AutoMapper.Collection/project.json

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"sdk": {`
`3`	`3`	`"version": "1.0.0-preview1-002702"`
`4`		`- }`
	`4`	`+ },`
	`5`	`+ "projects": []`
`5`	`6`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,11 +15,10 @@ public static class Extensions`
`15`	`15`	`/// <typeparam name="TSource">Source table type to be updated</typeparam>`
`16`	`16`	`/// <param name="source">DbSet to be updated</param>`
`17`	`17`	`/// <returns>Persistance object to Update or Remove data</returns>`
`18`		`- [Obsolete("Use version that passes instance of IMapper")]`
`19`	`18`	`public static IPersistance Persist<TSource>(this DbSet<TSource> source)`
`20`	`19`	`where TSource : class`
`21`	`20`	`{`
`22`		`- return new Persistance<TSource>(source, null);`
	`21`	`+ return new Persistance<TSource>(source, Mapper.Instance);`
`23`	`22`	`}`
`24`	`23`
`25`	`24`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -16,17 +16,16 @@ public class GenerateEntityFrameworkPrimaryKeyEquivilentExpressions<TDatabaseCon`
`16`	`16`	`/// </summary>`
`17`	`17`	`/// <param name="mapper">IMapper used to find TypeMap between classes</param>`
`18`	`18`	`public GenerateEntityFrameworkPrimaryKeyEquivilentExpressions(IMapper mapper)`
`19`		`- : base(new GenerateEntityFrameworkPrimaryKeyPropertyMaps<TDatabaseContext>(mapper))`
	`19`	`+ : base(new GenerateEntityFrameworkPrimaryKeyPropertyMaps<TDatabaseContext>(mapper.ConfigurationProvider))`
`20`	`20`	`{`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`/// <summary>`
`24`	`24`	`/// Generate EquivilencyExpressions based on EnityFramework's primary key`
`25`	`25`	`/// Uses static API's Mapper for finding TypeMap between classes`
`26`	`26`	`/// </summary>`
`27`		`- [Obsolete("Use version that passes instance of IMapper")]`
`28`	`27`	`public GenerateEntityFrameworkPrimaryKeyEquivilentExpressions()`
`29`		`- : base(new GenerateEntityFrameworkPrimaryKeyPropertyMaps<TDatabaseContext>(null))`
	`28`	`+ : base(new GenerateEntityFrameworkPrimaryKeyPropertyMaps<TDatabaseContext>(Mapper.Configuration))`
`30`	`29`	`{`
`31`	`30`	`}`
`32`	`31`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,21 +12,19 @@ namespace AutoMapper.EntityFramework`
`12`	`12`	`public class GenerateEntityFrameworkPrimaryKeyPropertyMaps<TDatabaseContext> : IGeneratePropertyMaps`
`13`	`13`	`where TDatabaseContext : IObjectContextAdapter, new()`
`14`	`14`	`{`
`15`		`- private readonly IMapper _mapper;`
	`15`	`+ private readonly IConfigurationProvider _configurationProvider;`
`16`	`16`
`17`	`17`	`private readonly TDatabaseContext _context = new TDatabaseContext();`
`18`	`18`	`private readonly MethodInfo _createObjectSetMethodInfo = typeof(ObjectContext).GetMethod("CreateObjectSet", Type.EmptyTypes);`
`19`	`19`
`20`		`- public GenerateEntityFrameworkPrimaryKeyPropertyMaps(IMapper mapper)`
	`20`	`+ public GenerateEntityFrameworkPrimaryKeyPropertyMaps(IConfigurationProvider configurationProvider)`
`21`	`21`	`{`
`22`		`- _mapper = mapper;`
	`22`	`+ _configurationProvider = configurationProvider;`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`public IEnumerable<PropertyMap> GeneratePropertyMaps(Type srcType, Type destType)`
`26`	`26`	`{`
`27`		`- var typeMap = _mapper == null`
`28`		`- ? (Mapper.Configuration as IConfigurationProvider).ResolveTypeMap(srcType, destType)`
`29`		`- : _mapper.ConfigurationProvider.ResolveTypeMap(srcType, destType);`
	`27`	`+ var typeMap = _configurationProvider.ResolveTypeMap(srcType, destType);`
`30`	`28`	`var propertyMaps = typeMap.GetPropertyMaps();`
`31`	`29`	`var createObjectSetMethod = _createObjectSetMethodInfo.MakeGenericMethod(destType);`
`32`	`30`	`dynamic objectSet = createObjectSetMethod.Invoke(_context.ObjectContext, null);`
Original file line number	Diff line number	Diff line change
`@@ -10,17 +10,16 @@ public class GetLinqToSQLPrimaryKeyExpression : GenerateEquivilentExpressionsBas`
`10`	`10`	`/// </summary>`
`11`	`11`	`/// <param name="mapper">IMapper used to find TypeMap between classes</param>`
`12`	`12`	`public GetLinqToSQLPrimaryKeyExpression(IMapper mapper)`
`13`		`- : base(new GetLinqToSQLPrimaryKeyProperties(mapper))`
	`13`	`+ : base(new GetLinqToSQLPrimaryKeyProperties(mapper.ConfigurationProvider))`
`14`	`14`	`{`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`/// <summary>`
`18`	`18`	`/// Generate EquivilencyExpressions based on LinqToSQL's primary key`
`19`	`19`	`/// Uses static API's Mapper for finding TypeMap between classes`
`20`	`20`	`/// </summary>`
`21`		`- [Obsolete("Use version that passes instance of IMapper")]`
`22`	`21`	`public GetLinqToSQLPrimaryKeyExpression()`
`23`		`- : base(new GetLinqToSQLPrimaryKeyProperties(null))`
	`22`	`+ : base(new GetLinqToSQLPrimaryKeyProperties(Mapper.Configuration))`
`24`	`23`	`{`
`25`	`24`	`}`
`26`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,18 +9,18 @@ namespace AutoMapper.Collection.LinqToSQL`
`9`	`9`	`{`
`10`	`10`	`public class GetLinqToSQLPrimaryKeyProperties : IGeneratePropertyMaps`
`11`	`11`	`{`
`12`		`- private readonly IMapper _mapper;`
`13`		`-`
`14`		`- public GetLinqToSQLPrimaryKeyProperties(IMapper mapper)`
	`12`	`+ private readonly IConfigurationProvider _configurationProvider;`
	`13`	`+`
	`14`	`+ public GetLinqToSQLPrimaryKeyProperties(IConfigurationProvider configurationProvider)`
`15`	`15`	`{`
`16`		`- _mapper = mapper;`
	`16`	`+ if (configurationProvider == null)`
	`17`	`+ throw new ArgumentNullException(nameof(configurationProvider));`
	`18`	`+ _configurationProvider = configurationProvider;`
`17`	`19`	`}`
`18`	`20`
`19`	`21`	`public IEnumerable<PropertyMap> GeneratePropertyMaps(Type srcType, Type destType)`
`20`	`22`	`{`
`21`		`- var typeMap = _mapper == null`
`22`		`- ? (Mapper.Configuration as IConfigurationProvider).ResolveTypeMap(srcType, destType)`
`23`		`- : _mapper.ConfigurationProvider.ResolveTypeMap(srcType, destType);`
	`23`	`+ var typeMap = _configurationProvider.ResolveTypeMap(srcType, destType);`
`24`	`24`	`var propertyMaps = typeMap.GetPropertyMaps();`
`25`	`25`
`26`	`26`	`var primaryKeyPropertyMatches = destType.GetProperties().Where(IsPrimaryKey).Select(m => propertyMaps.FirstOrDefault(p => p.DestinationProperty.Name == m.Name)).ToList();`